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/acnamesp.h>
17 #include <acpi/acresrc.h>
18 #include <acpi/acpi_bus.h>
20 #include <linux/pci-acpi.h>
23 struct acpi_osc_data
{
29 struct list_head sibiling
;
31 static LIST_HEAD(acpi_osc_data_list
);
33 struct acpi_osc_args
{
38 static DEFINE_MUTEX(pci_acpi_lock
);
40 static struct acpi_osc_data
*acpi_get_osc_data(acpi_handle handle
)
42 struct acpi_osc_data
*data
;
44 list_for_each_entry(data
, &acpi_osc_data_list
, sibiling
) {
45 if (data
->handle
== handle
)
48 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
51 INIT_LIST_HEAD(&data
->sibiling
);
52 data
->handle
= handle
;
53 list_add_tail(&data
->sibiling
, &acpi_osc_data_list
);
57 static u8 OSC_UUID
[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40,
58 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66};
60 static acpi_status
acpi_run_osc(acpi_handle handle
,
61 struct acpi_osc_args
*osc_args
)
64 struct acpi_object_list input
;
65 union acpi_object in_params
[4];
66 struct acpi_buffer output
= {ACPI_ALLOCATE_BUFFER
, NULL
};
67 union acpi_object
*out_obj
;
68 u32 errors
, flags
= osc_args
->capbuf
[OSC_QUERY_TYPE
];
70 /* Setting up input parameters */
72 input
.pointer
= in_params
;
73 in_params
[0].type
= ACPI_TYPE_BUFFER
;
74 in_params
[0].buffer
.length
= 16;
75 in_params
[0].buffer
.pointer
= OSC_UUID
;
76 in_params
[1].type
= ACPI_TYPE_INTEGER
;
77 in_params
[1].integer
.value
= 1;
78 in_params
[2].type
= ACPI_TYPE_INTEGER
;
79 in_params
[2].integer
.value
= 3;
80 in_params
[3].type
= ACPI_TYPE_BUFFER
;
81 in_params
[3].buffer
.length
= 12;
82 in_params
[3].buffer
.pointer
= (u8
*)osc_args
->capbuf
;
84 status
= acpi_evaluate_object(handle
, "_OSC", &input
, &output
);
85 if (ACPI_FAILURE(status
))
89 return AE_NULL_OBJECT
;
91 out_obj
= output
.pointer
;
92 if (out_obj
->type
!= ACPI_TYPE_BUFFER
) {
93 printk(KERN_DEBUG
"Evaluate _OSC returns wrong type\n");
97 /* Need to ignore the bit0 in result code */
98 errors
= *((u32
*)out_obj
->buffer
.pointer
) & ~(1 << 0);
100 if (errors
& OSC_REQUEST_ERROR
)
101 printk(KERN_DEBUG
"_OSC request fails\n");
102 if (errors
& OSC_INVALID_UUID_ERROR
)
103 printk(KERN_DEBUG
"_OSC invalid UUID\n");
104 if (errors
& OSC_INVALID_REVISION_ERROR
)
105 printk(KERN_DEBUG
"_OSC invalid revision\n");
106 if (errors
& OSC_CAPABILITIES_MASK_ERROR
) {
107 if (flags
& OSC_QUERY_ENABLE
)
109 printk(KERN_DEBUG
"_OSC FW not grant req. control\n");
117 if (flags
& OSC_QUERY_ENABLE
)
118 osc_args
->query_result
=
119 *((u32
*)(out_obj
->buffer
.pointer
+ 8));
123 kfree(output
.pointer
);
127 static acpi_status
__acpi_query_osc(u32 flags
, struct acpi_osc_data
*osc_data
)
131 struct acpi_osc_args osc_args
;
133 /* do _OSC query for all possible controls */
134 support_set
= osc_data
->support_set
| (flags
& OSC_SUPPORT_MASKS
);
135 osc_args
.capbuf
[OSC_QUERY_TYPE
] = OSC_QUERY_ENABLE
;
136 osc_args
.capbuf
[OSC_SUPPORT_TYPE
] = support_set
;
137 osc_args
.capbuf
[OSC_CONTROL_TYPE
] = OSC_CONTROL_MASKS
;
139 status
= acpi_run_osc(osc_data
->handle
, &osc_args
);
140 if (ACPI_SUCCESS(status
)) {
141 osc_data
->support_set
= support_set
;
142 osc_data
->query_result
= osc_args
.query_result
;
143 osc_data
->is_queried
= 1;
150 * pci_acpi_osc_support: Invoke _OSC indicating support for the given feature
151 * @flags: Bitmask of flags to support
153 * See the ACPI spec for the definition of the flags
155 int pci_acpi_osc_support(acpi_handle handle
, u32 flags
)
159 struct acpi_osc_data
*osc_data
;
162 status
= acpi_get_handle(handle
, "_OSC", &tmp
);
163 if (ACPI_FAILURE(status
))
166 mutex_lock(&pci_acpi_lock
);
167 osc_data
= acpi_get_osc_data(handle
);
169 printk(KERN_ERR
"acpi osc data array is full\n");
174 __acpi_query_osc(flags
, osc_data
);
176 mutex_unlock(&pci_acpi_lock
);
181 * pci_osc_control_set - commit requested control to Firmware
182 * @handle: acpi_handle for the target ACPI object
183 * @flags: driver's requested control bits
185 * Attempt to take control from Firmware on requested control bits.
187 acpi_status
pci_osc_control_set(acpi_handle handle
, u32 flags
)
190 u32 ctrlset
, control_set
;
192 struct acpi_osc_data
*osc_data
;
193 struct acpi_osc_args osc_args
;
195 status
= acpi_get_handle(handle
, "_OSC", &tmp
);
196 if (ACPI_FAILURE(status
))
199 mutex_lock(&pci_acpi_lock
);
200 osc_data
= acpi_get_osc_data(handle
);
202 printk(KERN_ERR
"acpi osc data array is full\n");
207 ctrlset
= (flags
& OSC_CONTROL_MASKS
);
213 if (!osc_data
->is_queried
) {
214 status
= __acpi_query_osc(osc_data
->support_set
, osc_data
);
215 if (ACPI_FAILURE(status
))
219 if ((osc_data
->query_result
& ctrlset
) != ctrlset
) {
224 control_set
= osc_data
->control_set
| ctrlset
;
225 osc_args
.capbuf
[OSC_QUERY_TYPE
] = 0;
226 osc_args
.capbuf
[OSC_SUPPORT_TYPE
] = osc_data
->support_set
;
227 osc_args
.capbuf
[OSC_CONTROL_TYPE
] = control_set
;
228 status
= acpi_run_osc(handle
, &osc_args
);
229 if (ACPI_SUCCESS(status
))
230 osc_data
->control_set
= control_set
;
232 mutex_unlock(&pci_acpi_lock
);
235 EXPORT_SYMBOL(pci_osc_control_set
);
238 * _SxD returns the D-state with the highest power
239 * (lowest D-state number) supported in the S-state "x".
241 * If the devices does not have a _PRW
242 * (Power Resources for Wake) supporting system wakeup from "x"
243 * then the OS is free to choose a lower power (higher number
244 * D-state) than the return value from _SxD.
246 * But if _PRW is enabled at S-state "x", the OS
247 * must not choose a power lower than _SxD --
248 * unless the device has an _SxW method specifying
249 * the lowest power (highest D-state number) the device
250 * may enter while still able to wake the system.
252 * ie. depending on global OS policy:
254 * if (_PRW at S-state x)
255 * choose from highest power _SxD to lowest power _SxW
256 * else // no _PRW at S-state x
257 * choose highest power _SxD or any lower power
260 static pci_power_t
acpi_pci_choose_state(struct pci_dev
*pdev
)
264 acpi_state
= acpi_pm_device_sleep_state(&pdev
->dev
, NULL
);
266 return PCI_POWER_ERROR
;
268 switch (acpi_state
) {
278 return PCI_POWER_ERROR
;
281 static bool acpi_pci_power_manageable(struct pci_dev
*dev
)
283 acpi_handle handle
= DEVICE_ACPI_HANDLE(&dev
->dev
);
285 return handle
? acpi_bus_power_manageable(handle
) : false;
288 static int acpi_pci_set_power_state(struct pci_dev
*dev
, pci_power_t state
)
290 acpi_handle handle
= DEVICE_ACPI_HANDLE(&dev
->dev
);
292 static const u8 state_conv
[] = {
293 [PCI_D0
] = ACPI_STATE_D0
,
294 [PCI_D1
] = ACPI_STATE_D1
,
295 [PCI_D2
] = ACPI_STATE_D2
,
296 [PCI_D3hot
] = ACPI_STATE_D3
,
297 [PCI_D3cold
] = ACPI_STATE_D3
301 /* If the ACPI device has _EJ0, ignore the device */
302 if (!handle
|| ACPI_SUCCESS(acpi_get_handle(handle
, "_EJ0", &tmp
)))
311 error
= acpi_bus_set_power(handle
, state_conv
[state
]);
315 dev_printk(KERN_INFO
, &dev
->dev
,
316 "power state changed by ACPI to D%d\n", state
);
321 static bool acpi_pci_can_wakeup(struct pci_dev
*dev
)
323 acpi_handle handle
= DEVICE_ACPI_HANDLE(&dev
->dev
);
325 return handle
? acpi_bus_can_wakeup(handle
) : false;
328 static int acpi_pci_sleep_wake(struct pci_dev
*dev
, bool enable
)
330 int error
= acpi_pm_device_sleep_wake(&dev
->dev
, enable
);
333 dev_printk(KERN_INFO
, &dev
->dev
,
334 "wake-up capability %s by ACPI\n",
335 enable
? "enabled" : "disabled");
339 static struct pci_platform_pm_ops acpi_pci_platform_pm
= {
340 .is_manageable
= acpi_pci_power_manageable
,
341 .set_state
= acpi_pci_set_power_state
,
342 .choose_state
= acpi_pci_choose_state
,
343 .can_wakeup
= acpi_pci_can_wakeup
,
344 .sleep_wake
= acpi_pci_sleep_wake
,
348 static int acpi_pci_find_device(struct device
*dev
, acpi_handle
*handle
)
350 struct pci_dev
* pci_dev
;
353 pci_dev
= to_pci_dev(dev
);
354 /* Please ref to ACPI spec for the syntax of _ADR */
355 addr
= (PCI_SLOT(pci_dev
->devfn
) << 16) | PCI_FUNC(pci_dev
->devfn
);
356 *handle
= acpi_get_child(DEVICE_ACPI_HANDLE(dev
->parent
), addr
);
362 static int acpi_pci_find_root_bridge(struct device
*dev
, acpi_handle
*handle
)
365 unsigned int seg
, bus
;
368 * The string should be the same as root bridge's name
369 * Please look at 'pci_scan_bus_parented'
371 num
= sscanf(dev_name(dev
), "pci%04x:%02x", &seg
, &bus
);
374 *handle
= acpi_get_pci_rootbridge_handle(seg
, bus
);
380 static struct acpi_bus_type acpi_pci_bus
= {
381 .bus
= &pci_bus_type
,
382 .find_device
= acpi_pci_find_device
,
383 .find_bridge
= acpi_pci_find_root_bridge
,
386 static int __init
acpi_pci_init(void)
390 if (acpi_gbl_FADT
.boot_flags
& BAF_MSI_NOT_SUPPORTED
) {
391 printk(KERN_INFO
"ACPI FADT declares the system doesn't support MSI, so disable it\n");
395 if (acpi_gbl_FADT
.boot_flags
& BAF_PCIE_ASPM_CONTROL
) {
396 printk(KERN_INFO
"ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
400 ret
= register_acpi_bus_type(&acpi_pci_bus
);
403 pci_set_platform_pm(&acpi_pci_platform_pm
);
406 arch_initcall(acpi_pci_init
);