3 * Purpose: Provide PCI support in ACPI
5 * Copyright (C) 2005 David Shaohua Li <shaohua.li@intel.com>
6 * Copyright (C) 2004 Tom Long Nguyen <tom.l.nguyen@intel.com>
7 * Copyright (C) 2004 Intel Corp.
10 #include <linux/delay.h>
11 #include <linux/init.h>
12 #include <linux/pci.h>
13 #include <linux/module.h>
14 #include <linux/pci-aspm.h>
15 #include <acpi/acpi.h>
16 #include <acpi/acpi_bus.h>
18 #include <linux/pci-acpi.h>
21 struct acpi_osc_data
{
27 struct list_head sibiling
;
29 static LIST_HEAD(acpi_osc_data_list
);
31 struct acpi_osc_args
{
35 static DEFINE_MUTEX(pci_acpi_lock
);
37 static struct acpi_osc_data
*acpi_get_osc_data(acpi_handle handle
)
39 struct acpi_osc_data
*data
;
41 list_for_each_entry(data
, &acpi_osc_data_list
, sibiling
) {
42 if (data
->handle
== handle
)
45 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
48 INIT_LIST_HEAD(&data
->sibiling
);
49 data
->handle
= handle
;
50 list_add_tail(&data
->sibiling
, &acpi_osc_data_list
);
54 static u8 OSC_UUID
[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40,
55 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66};
57 static acpi_status
acpi_run_osc(acpi_handle handle
,
58 struct acpi_osc_args
*osc_args
, u32
*retval
)
61 struct acpi_object_list input
;
62 union acpi_object in_params
[4];
63 struct acpi_buffer output
= {ACPI_ALLOCATE_BUFFER
, NULL
};
64 union acpi_object
*out_obj
;
65 u32 errors
, flags
= osc_args
->capbuf
[OSC_QUERY_TYPE
];
67 /* Setting up input parameters */
69 input
.pointer
= in_params
;
70 in_params
[0].type
= ACPI_TYPE_BUFFER
;
71 in_params
[0].buffer
.length
= 16;
72 in_params
[0].buffer
.pointer
= OSC_UUID
;
73 in_params
[1].type
= ACPI_TYPE_INTEGER
;
74 in_params
[1].integer
.value
= 1;
75 in_params
[2].type
= ACPI_TYPE_INTEGER
;
76 in_params
[2].integer
.value
= 3;
77 in_params
[3].type
= ACPI_TYPE_BUFFER
;
78 in_params
[3].buffer
.length
= 12;
79 in_params
[3].buffer
.pointer
= (u8
*)osc_args
->capbuf
;
81 status
= acpi_evaluate_object(handle
, "_OSC", &input
, &output
);
82 if (ACPI_FAILURE(status
))
86 return AE_NULL_OBJECT
;
88 out_obj
= output
.pointer
;
89 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
90 printk(KERN_DEBUG
"Evaluate _OSC returns wrong type\n");
94 /* Need to ignore the bit0 in result code */
95 errors
= *((u32
*)out_obj
->buffer
.pointer
) & ~(1 << 0);
97 if (errors
& OSC_REQUEST_ERROR
)
98 printk(KERN_DEBUG
"_OSC request fails\n");
99 if (errors
& OSC_INVALID_UUID_ERROR
)
100 printk(KERN_DEBUG
"_OSC invalid UUID\n");
101 if (errors
& OSC_INVALID_REVISION_ERROR
)
102 printk(KERN_DEBUG
"_OSC invalid revision\n");
103 if (errors
& OSC_CAPABILITIES_MASK_ERROR
) {
104 if (flags
& OSC_QUERY_ENABLE
)
106 printk(KERN_DEBUG
"_OSC FW not grant req. control\n");
114 *retval
= *((u32
*)(out_obj
->buffer
.pointer
+ 8));
118 kfree(output
.pointer
);
122 static acpi_status
__acpi_query_osc(u32 flags
, struct acpi_osc_data
*osc_data
)
125 u32 support_set
, result
;
126 struct acpi_osc_args osc_args
;
128 /* do _OSC query for all possible controls */
129 support_set
= osc_data
->support_set
| (flags
& OSC_SUPPORT_MASKS
);
130 osc_args
.capbuf
[OSC_QUERY_TYPE
] = OSC_QUERY_ENABLE
;
131 osc_args
.capbuf
[OSC_SUPPORT_TYPE
] = support_set
;
132 osc_args
.capbuf
[OSC_CONTROL_TYPE
] = OSC_CONTROL_MASKS
;
134 status
= acpi_run_osc(osc_data
->handle
, &osc_args
, &result
);
135 if (ACPI_SUCCESS(status
)) {
136 osc_data
->support_set
= support_set
;
137 osc_data
->control_query
= result
;
138 osc_data
->is_queried
= 1;
145 * pci_acpi_osc_support: Invoke _OSC indicating support for the given feature
146 * @flags: Bitmask of flags to support
148 * See the ACPI spec for the definition of the flags
150 int pci_acpi_osc_support(acpi_handle handle
, u32 flags
)
154 struct acpi_osc_data
*osc_data
;
157 status
= acpi_get_handle(handle
, "_OSC", &tmp
);
158 if (ACPI_FAILURE(status
))
161 mutex_lock(&pci_acpi_lock
);
162 osc_data
= acpi_get_osc_data(handle
);
164 printk(KERN_ERR
"acpi osc data array is full\n");
169 __acpi_query_osc(flags
, osc_data
);
171 mutex_unlock(&pci_acpi_lock
);
176 * pci_osc_control_set - commit requested control to Firmware
177 * @handle: acpi_handle for the target ACPI object
178 * @flags: driver's requested control bits
180 * Attempt to take control from Firmware on requested control bits.
182 acpi_status
pci_osc_control_set(acpi_handle handle
, u32 flags
)
185 u32 control_req
, control_set
, result
;
187 struct acpi_osc_data
*osc_data
;
188 struct acpi_osc_args osc_args
;
190 status
= acpi_get_handle(handle
, "_OSC", &tmp
);
191 if (ACPI_FAILURE(status
))
194 mutex_lock(&pci_acpi_lock
);
195 osc_data
= acpi_get_osc_data(handle
);
197 printk(KERN_ERR
"acpi osc data array is full\n");
202 control_req
= (flags
& OSC_CONTROL_MASKS
);
208 /* No need to evaluate _OSC if the control was already granted. */
209 if ((osc_data
->control_set
& control_req
) == control_req
)
212 if (!osc_data
->is_queried
) {
213 status
= __acpi_query_osc(osc_data
->support_set
, osc_data
);
214 if (ACPI_FAILURE(status
))
218 if ((osc_data
->control_query
& control_req
) != control_req
) {
223 control_set
= osc_data
->control_set
| control_req
;
224 osc_args
.capbuf
[OSC_QUERY_TYPE
] = 0;
225 osc_args
.capbuf
[OSC_SUPPORT_TYPE
] = osc_data
->support_set
;
226 osc_args
.capbuf
[OSC_CONTROL_TYPE
] = control_set
;
227 status
= acpi_run_osc(handle
, &osc_args
, &result
);
228 if (ACPI_SUCCESS(status
))
229 osc_data
->control_set
= result
;
231 mutex_unlock(&pci_acpi_lock
);
234 EXPORT_SYMBOL(pci_osc_control_set
);
237 * _SxD returns the D-state with the highest power
238 * (lowest D-state number) supported in the S-state "x".
240 * If the devices does not have a _PRW
241 * (Power Resources for Wake) supporting system wakeup from "x"
242 * then the OS is free to choose a lower power (higher number
243 * D-state) than the return value from _SxD.
245 * But if _PRW is enabled at S-state "x", the OS
246 * must not choose a power lower than _SxD --
247 * unless the device has an _SxW method specifying
248 * the lowest power (highest D-state number) the device
249 * may enter while still able to wake the system.
251 * ie. depending on global OS policy:
253 * if (_PRW at S-state x)
254 * choose from highest power _SxD to lowest power _SxW
255 * else // no _PRW at S-state x
256 * choose highest power _SxD or any lower power
259 static pci_power_t
acpi_pci_choose_state(struct pci_dev
*pdev
)
263 acpi_state
= acpi_pm_device_sleep_state(&pdev
->dev
, NULL
);
265 return PCI_POWER_ERROR
;
267 switch (acpi_state
) {
277 return PCI_POWER_ERROR
;
280 static bool acpi_pci_power_manageable(struct pci_dev
*dev
)
282 acpi_handle handle
= DEVICE_ACPI_HANDLE(&dev
->dev
);
284 return handle
? acpi_bus_power_manageable(handle
) : false;
287 static int acpi_pci_set_power_state(struct pci_dev
*dev
, pci_power_t state
)
289 acpi_handle handle
= DEVICE_ACPI_HANDLE(&dev
->dev
);
291 static const u8 state_conv
[] = {
292 [PCI_D0
] = ACPI_STATE_D0
,
293 [PCI_D1
] = ACPI_STATE_D1
,
294 [PCI_D2
] = ACPI_STATE_D2
,
295 [PCI_D3hot
] = ACPI_STATE_D3
,
296 [PCI_D3cold
] = ACPI_STATE_D3
300 /* If the ACPI device has _EJ0, ignore the device */
301 if (!handle
|| ACPI_SUCCESS(acpi_get_handle(handle
, "_EJ0", &tmp
)))
310 error
= acpi_bus_set_power(handle
, state_conv
[state
]);
314 dev_printk(KERN_INFO
, &dev
->dev
,
315 "power state changed by ACPI to D%d\n", state
);
320 static bool acpi_pci_can_wakeup(struct pci_dev
*dev
)
322 acpi_handle handle
= DEVICE_ACPI_HANDLE(&dev
->dev
);
324 return handle
? acpi_bus_can_wakeup(handle
) : false;
327 static int acpi_pci_sleep_wake(struct pci_dev
*dev
, bool enable
)
329 int error
= acpi_pm_device_sleep_wake(&dev
->dev
, enable
);
332 dev_printk(KERN_INFO
, &dev
->dev
,
333 "wake-up capability %s by ACPI\n",
334 enable
? "enabled" : "disabled");
338 static struct pci_platform_pm_ops acpi_pci_platform_pm
= {
339 .is_manageable
= acpi_pci_power_manageable
,
340 .set_state
= acpi_pci_set_power_state
,
341 .choose_state
= acpi_pci_choose_state
,
342 .can_wakeup
= acpi_pci_can_wakeup
,
343 .sleep_wake
= acpi_pci_sleep_wake
,
347 static int acpi_pci_find_device(struct device
*dev
, acpi_handle
*handle
)
349 struct pci_dev
* pci_dev
;
352 pci_dev
= to_pci_dev(dev
);
353 /* Please ref to ACPI spec for the syntax of _ADR */
354 addr
= (PCI_SLOT(pci_dev
->devfn
) << 16) | PCI_FUNC(pci_dev
->devfn
);
355 *handle
= acpi_get_child(DEVICE_ACPI_HANDLE(dev
->parent
), addr
);
361 static int acpi_pci_find_root_bridge(struct device
*dev
, acpi_handle
*handle
)
364 unsigned int seg
, bus
;
367 * The string should be the same as root bridge's name
368 * Please look at 'pci_scan_bus_parented'
370 num
= sscanf(dev_name(dev
), "pci%04x:%02x", &seg
, &bus
);
373 *handle
= acpi_get_pci_rootbridge_handle(seg
, bus
);
379 static struct acpi_bus_type acpi_pci_bus
= {
380 .bus
= &pci_bus_type
,
381 .find_device
= acpi_pci_find_device
,
382 .find_bridge
= acpi_pci_find_root_bridge
,
385 static int __init
acpi_pci_init(void)
389 if (acpi_gbl_FADT
.boot_flags
& ACPI_FADT_NO_MSI
) {
390 printk(KERN_INFO
"ACPI FADT declares the system doesn't support MSI, so disable it\n");
394 if (acpi_gbl_FADT
.boot_flags
& ACPI_FADT_NO_ASPM
) {
395 printk(KERN_INFO
"ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
399 ret
= register_acpi_bus_type(&acpi_pci_bus
);
402 pci_set_platform_pm(&acpi_pci_platform_pm
);
405 arch_initcall(acpi_pci_init
);