blob: 9d6fc8e6285d0c557a5e1778e468f49066ff4da5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * File: pci-acpi.c
Len Browna406d9e2005-03-23 16:16:03 -05003 * Purpose: Provide PCI support in ACPI
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
David Shaohua Li84df749f2005-03-18 18:53:36 -05005 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
9
10#include <linux/delay.h>
11#include <linux/init.h>
12#include <linux/pci.h>
13#include <linux/module.h>
14#include <acpi/acpi.h>
15#include <acpi/acnamesp.h>
16#include <acpi/acresrc.h>
17#include <acpi/acpi_bus.h>
18
19#include <linux/pci-acpi.h>
David Shaohua Li0f644742005-03-19 00:15:48 -050020#include "pci.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Shaohua Lia5d1c872008-05-12 10:48:10 +080022struct acpi_osc_data {
23 acpi_handle handle;
24 u32 ctrlset_buf[3];
25 u32 global_ctrlsets;
26 struct list_head sibiling;
27};
28static LIST_HEAD(acpi_osc_data_list);
29
30static struct acpi_osc_data *acpi_get_osc_data(acpi_handle handle)
31{
32 struct acpi_osc_data *data;
33
34 list_for_each_entry(data, &acpi_osc_data_list, sibiling) {
35 if (data->handle == handle)
36 return data;
37 }
38 data = kzalloc(sizeof(*data), GFP_KERNEL);
39 if (!data)
40 return NULL;
41 INIT_LIST_HEAD(&data->sibiling);
42 data->handle = handle;
43 list_add_tail(&data->sibiling, &acpi_osc_data_list);
44 return data;
45}
46
Greg KHbc56b9e2005-04-08 14:53:31 +090047static u8 OSC_UUID[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40, 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66};
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49static acpi_status
50acpi_query_osc (
51 acpi_handle handle,
52 u32 level,
53 void *context,
54 void **retval )
55{
56 acpi_status status;
57 struct acpi_object_list input;
58 union acpi_object in_params[4];
Kristen Accardi593ee202006-05-20 15:00:08 -070059 struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
60 union acpi_object *out_obj;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 u32 osc_dw0;
Kristen Carlson Accardi0dcb2b72006-10-30 13:08:12 -080062 acpi_status *ret_status = (acpi_status *)retval;
Kenji Kaneshigec4e5fad2008-05-13 16:48:50 +090063 struct acpi_osc_data *osc_data;
Shaohua Lia5d1c872008-05-12 10:48:10 +080064 u32 flags = (unsigned long)context, temp;
Kenji Kaneshigec4e5fad2008-05-13 16:48:50 +090065 acpi_handle tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Kenji Kaneshigec4e5fad2008-05-13 16:48:50 +090067 status = acpi_get_handle(handle, "_OSC", &tmp);
68 if (ACPI_FAILURE(status))
69 return status;
70
71 osc_data = acpi_get_osc_data(handle);
Shaohua Lia5d1c872008-05-12 10:48:10 +080072 if (!osc_data) {
73 printk(KERN_ERR "acpi osc data array is full\n");
74 return AE_ERROR;
75 }
76
77 osc_data->ctrlset_buf[OSC_SUPPORT_TYPE] |= (flags & OSC_SUPPORT_MASKS);
78
79 /* do _OSC query for all possible controls */
80 temp = osc_data->ctrlset_buf[OSC_CONTROL_TYPE];
81 osc_data->ctrlset_buf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
82 osc_data->ctrlset_buf[OSC_CONTROL_TYPE] = OSC_CONTROL_MASKS;
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 /* Setting up input parameters */
85 input.count = 4;
86 input.pointer = in_params;
87 in_params[0].type = ACPI_TYPE_BUFFER;
88 in_params[0].buffer.length = 16;
89 in_params[0].buffer.pointer = OSC_UUID;
90 in_params[1].type = ACPI_TYPE_INTEGER;
91 in_params[1].integer.value = 1;
92 in_params[2].type = ACPI_TYPE_INTEGER;
93 in_params[2].integer.value = 3;
94 in_params[3].type = ACPI_TYPE_BUFFER;
95 in_params[3].buffer.length = 12;
Shaohua Lia5d1c872008-05-12 10:48:10 +080096 in_params[3].buffer.pointer = (u8 *)osc_data->ctrlset_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98 status = acpi_evaluate_object(handle, "_OSC", &input, &output);
Shaohua Lia5d1c872008-05-12 10:48:10 +080099 if (ACPI_FAILURE(status))
100 goto out_nofree;
Kristen Accardi593ee202006-05-20 15:00:08 -0700101 out_obj = output.pointer;
102
103 if (out_obj->type != ACPI_TYPE_BUFFER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 printk(KERN_DEBUG
105 "Evaluate _OSC returns wrong type\n");
Kristen Accardi593ee202006-05-20 15:00:08 -0700106 status = AE_TYPE;
107 goto query_osc_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 }
Kristen Accardi593ee202006-05-20 15:00:08 -0700109 osc_dw0 = *((u32 *) out_obj->buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 if (osc_dw0) {
111 if (osc_dw0 & OSC_REQUEST_ERROR)
112 printk(KERN_DEBUG "_OSC request fails\n");
113 if (osc_dw0 & OSC_INVALID_UUID_ERROR)
114 printk(KERN_DEBUG "_OSC invalid UUID\n");
115 if (osc_dw0 & OSC_INVALID_REVISION_ERROR)
116 printk(KERN_DEBUG "_OSC invalid revision\n");
117 if (osc_dw0 & OSC_CAPABILITIES_MASK_ERROR) {
118 /* Update Global Control Set */
Shaohua Lia5d1c872008-05-12 10:48:10 +0800119 osc_data->global_ctrlsets =
120 *((u32 *)(out_obj->buffer.pointer + 8));
Kristen Accardi593ee202006-05-20 15:00:08 -0700121 status = AE_OK;
122 goto query_osc_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 }
Kristen Accardi593ee202006-05-20 15:00:08 -0700124 status = AE_ERROR;
125 goto query_osc_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 }
127
128 /* Update Global Control Set */
Shaohua Lia5d1c872008-05-12 10:48:10 +0800129 osc_data->global_ctrlsets = *((u32 *)(out_obj->buffer.pointer + 8));
Kristen Accardi593ee202006-05-20 15:00:08 -0700130 status = AE_OK;
131
132query_osc_out:
133 kfree(output.pointer);
Shaohua Lia5d1c872008-05-12 10:48:10 +0800134out_nofree:
Kristen Carlson Accardi0dcb2b72006-10-30 13:08:12 -0800135 *ret_status = status;
Shaohua Lia5d1c872008-05-12 10:48:10 +0800136
137 osc_data->ctrlset_buf[OSC_QUERY_TYPE] = !OSC_QUERY_ENABLE;
138 osc_data->ctrlset_buf[OSC_CONTROL_TYPE] = temp;
139 if (ACPI_FAILURE(status)) {
140 /* no osc support at all */
141 osc_data->ctrlset_buf[OSC_SUPPORT_TYPE] = 0;
142 }
143
Kristen Accardi593ee202006-05-20 15:00:08 -0700144 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145}
146
147
148static acpi_status
149acpi_run_osc (
150 acpi_handle handle,
rajesh.shah@intel.com427bf532005-10-31 16:20:11 -0800151 void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
153 acpi_status status;
154 struct acpi_object_list input;
155 union acpi_object in_params[4];
Kristen Accardi593ee202006-05-20 15:00:08 -0700156 struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
157 union acpi_object *out_obj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 u32 osc_dw0;
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 /* Setting up input parameters */
161 input.count = 4;
162 input.pointer = in_params;
163 in_params[0].type = ACPI_TYPE_BUFFER;
164 in_params[0].buffer.length = 16;
165 in_params[0].buffer.pointer = OSC_UUID;
166 in_params[1].type = ACPI_TYPE_INTEGER;
167 in_params[1].integer.value = 1;
168 in_params[2].type = ACPI_TYPE_INTEGER;
169 in_params[2].integer.value = 3;
170 in_params[3].type = ACPI_TYPE_BUFFER;
171 in_params[3].buffer.length = 12;
172 in_params[3].buffer.pointer = (u8 *)context;
173
174 status = acpi_evaluate_object(handle, "_OSC", &input, &output);
Zhang, Yanmin8d29bfb2007-06-06 11:44:16 +0800175 if (ACPI_FAILURE (status))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return status;
Zhang, Yanmin8d29bfb2007-06-06 11:44:16 +0800177
Kristen Accardi593ee202006-05-20 15:00:08 -0700178 out_obj = output.pointer;
179 if (out_obj->type != ACPI_TYPE_BUFFER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 printk(KERN_DEBUG
181 "Evaluate _OSC returns wrong type\n");
Kristen Accardi593ee202006-05-20 15:00:08 -0700182 status = AE_TYPE;
183 goto run_osc_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 }
Kristen Accardi593ee202006-05-20 15:00:08 -0700185 osc_dw0 = *((u32 *) out_obj->buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 if (osc_dw0) {
187 if (osc_dw0 & OSC_REQUEST_ERROR)
188 printk(KERN_DEBUG "_OSC request fails\n");
189 if (osc_dw0 & OSC_INVALID_UUID_ERROR)
190 printk(KERN_DEBUG "_OSC invalid UUID\n");
191 if (osc_dw0 & OSC_INVALID_REVISION_ERROR)
192 printk(KERN_DEBUG "_OSC invalid revision\n");
193 if (osc_dw0 & OSC_CAPABILITIES_MASK_ERROR) {
194 printk(KERN_DEBUG "_OSC FW not grant req. control\n");
Kristen Accardi593ee202006-05-20 15:00:08 -0700195 status = AE_SUPPORT;
196 goto run_osc_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 }
Kristen Accardi593ee202006-05-20 15:00:08 -0700198 status = AE_ERROR;
199 goto run_osc_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 }
Kristen Accardi593ee202006-05-20 15:00:08 -0700201 status = AE_OK;
202
203run_osc_out:
204 kfree(output.pointer);
205 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
208/**
Andrew Pattersonc2778352008-01-22 17:18:12 -0700209 * __pci_osc_support_set - register OS support to Firmware
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 * @flags: OS support bits
Randy Dunlap5958f1a2008-02-03 15:06:25 -0800211 * @hid: hardware ID
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 *
213 * Update OS support fields and doing a _OSC Query to obtain an update
214 * from Firmware on supported control bits.
215 **/
Andrew Pattersonc2778352008-01-22 17:18:12 -0700216acpi_status __pci_osc_support_set(u32 flags, const char *hid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
Kenji Kaneshige21e2b0a2008-05-08 14:37:25 +0900218 acpi_status retval = AE_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220 if (!(flags & OSC_SUPPORT_MASKS)) {
221 return AE_TYPE;
222 }
Andrew Pattersonc2778352008-01-22 17:18:12 -0700223 acpi_get_devices(hid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 acpi_query_osc,
Shaohua Lia5d1c872008-05-12 10:48:10 +0800225 (void *)(unsigned long)flags,
Kristen Carlson Accardi0dcb2b72006-10-30 13:08:12 -0800226 (void **) &retval );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return AE_OK;
228}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
230/**
231 * pci_osc_control_set - commit requested control to Firmware
Randy Dunlapf3666332005-11-23 15:45:04 -0800232 * @handle: acpi_handle for the target ACPI object
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 * @flags: driver's requested control bits
234 *
235 * Attempt to take control from Firmware on requested control bits.
236 **/
rajesh.shah@intel.com427bf532005-10-31 16:20:11 -0800237acpi_status pci_osc_control_set(acpi_handle handle, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
239 acpi_status status;
240 u32 ctrlset;
Kenji Kaneshige34a65052008-05-12 22:55:45 +0900241 acpi_handle tmp;
242 struct acpi_osc_data *osc_data;
Shaohua Lia5d1c872008-05-12 10:48:10 +0800243
Kenji Kaneshige34a65052008-05-12 22:55:45 +0900244 status = acpi_get_handle(handle, "_OSC", &tmp);
245 if (ACPI_FAILURE(status))
246 return status;
247
248 osc_data = acpi_get_osc_data(handle);
Shaohua Lia5d1c872008-05-12 10:48:10 +0800249 if (!osc_data) {
250 printk(KERN_ERR "acpi osc data array is full\n");
251 return AE_ERROR;
252 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254 ctrlset = (flags & OSC_CONTROL_MASKS);
255 if (!ctrlset) {
256 return AE_TYPE;
257 }
Shaohua Lia5d1c872008-05-12 10:48:10 +0800258 if (osc_data->ctrlset_buf[OSC_SUPPORT_TYPE] &&
259 ((osc_data->global_ctrlsets & ctrlset) != ctrlset)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 return AE_SUPPORT;
261 }
Shaohua Lia5d1c872008-05-12 10:48:10 +0800262 osc_data->ctrlset_buf[OSC_CONTROL_TYPE] |= ctrlset;
263 status = acpi_run_osc(handle, osc_data->ctrlset_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 if (ACPI_FAILURE (status)) {
Shaohua Lia5d1c872008-05-12 10:48:10 +0800265 osc_data->ctrlset_buf[OSC_CONTROL_TYPE] &= ~ctrlset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 }
267
268 return status;
269}
270EXPORT_SYMBOL(pci_osc_control_set);
David Shaohua Li84df749f2005-03-18 18:53:36 -0500271
Len Brown673d5b42007-07-28 03:33:16 -0400272#ifdef CONFIG_ACPI_SLEEP
David Shaohua Li0f644742005-03-19 00:15:48 -0500273/*
274 * _SxD returns the D-state with the highest power
275 * (lowest D-state number) supported in the S-state "x".
276 *
277 * If the devices does not have a _PRW
278 * (Power Resources for Wake) supporting system wakeup from "x"
279 * then the OS is free to choose a lower power (higher number
280 * D-state) than the return value from _SxD.
281 *
282 * But if _PRW is enabled at S-state "x", the OS
283 * must not choose a power lower than _SxD --
284 * unless the device has an _SxW method specifying
285 * the lowest power (highest D-state number) the device
286 * may enter while still able to wake the system.
287 *
288 * ie. depending on global OS policy:
289 *
290 * if (_PRW at S-state x)
291 * choose from highest power _SxD to lowest power _SxW
292 * else // no _PRW at S-state x
293 * choose highest power _SxD or any lower power
David Shaohua Li0f644742005-03-19 00:15:48 -0500294 */
295
Shaohua Liab826ca2007-07-20 10:03:22 +0800296static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev,
297 pm_message_t state)
David Shaohua Li0f644742005-03-19 00:15:48 -0500298{
Shaohua Liab826ca2007-07-20 10:03:22 +0800299 int acpi_state;
David Shaohua Li0f644742005-03-19 00:15:48 -0500300
Shaohua Liab826ca2007-07-20 10:03:22 +0800301 acpi_state = acpi_pm_device_sleep_state(&pdev->dev,
302 device_may_wakeup(&pdev->dev), NULL);
303 if (acpi_state < 0)
304 return PCI_POWER_ERROR;
305
306 switch (acpi_state) {
307 case ACPI_STATE_D0:
308 return PCI_D0;
309 case ACPI_STATE_D1:
310 return PCI_D1;
311 case ACPI_STATE_D2:
312 return PCI_D2;
313 case ACPI_STATE_D3:
314 return PCI_D3hot;
315 }
316 return PCI_POWER_ERROR;
David Shaohua Li0f644742005-03-19 00:15:48 -0500317}
Len Brown673d5b42007-07-28 03:33:16 -0400318#endif
David Shaohua Li0f644742005-03-19 00:15:48 -0500319
David Shaohua Lib9131002005-03-19 00:16:18 -0500320static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
321{
322 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
Shaohua Li10b3dca2007-07-20 10:03:25 +0800323 acpi_handle tmp;
David Brownell583c3772008-02-22 21:41:51 -0800324 static const u8 state_conv[] = {
325 [PCI_D0] = ACPI_STATE_D0,
326 [PCI_D1] = ACPI_STATE_D1,
327 [PCI_D2] = ACPI_STATE_D2,
328 [PCI_D3hot] = ACPI_STATE_D3,
329 [PCI_D3cold] = ACPI_STATE_D3
David Shaohua Lib9131002005-03-19 00:16:18 -0500330 };
David Shaohua Lib9131002005-03-19 00:16:18 -0500331
332 if (!handle)
333 return -ENODEV;
Shaohua Li10b3dca2007-07-20 10:03:25 +0800334 /* If the ACPI device has _EJ0, ignore the device */
335 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
336 return 0;
David Brownell583c3772008-02-22 21:41:51 -0800337
338 switch (state) {
339 case PCI_D0:
340 case PCI_D1:
341 case PCI_D2:
342 case PCI_D3hot:
343 case PCI_D3cold:
344 return acpi_bus_set_power(handle, state_conv[state]);
345 }
346 return -EINVAL;
David Shaohua Lib9131002005-03-19 00:16:18 -0500347}
348
349
David Shaohua Li84df749f2005-03-18 18:53:36 -0500350/* ACPI bus type */
Muthu Kumar9c273b92006-04-28 00:42:21 -0700351static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
David Shaohua Li84df749f2005-03-18 18:53:36 -0500352{
353 struct pci_dev * pci_dev;
354 acpi_integer addr;
355
356 pci_dev = to_pci_dev(dev);
357 /* Please ref to ACPI spec for the syntax of _ADR */
358 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
359 *handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr);
360 if (!*handle)
361 return -ENODEV;
362 return 0;
363}
364
Muthu Kumar9c273b92006-04-28 00:42:21 -0700365static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
David Shaohua Li84df749f2005-03-18 18:53:36 -0500366{
367 int num;
368 unsigned int seg, bus;
369
370 /*
371 * The string should be the same as root bridge's name
372 * Please look at 'pci_scan_bus_parented'
373 */
374 num = sscanf(dev->bus_id, "pci%04x:%02x", &seg, &bus);
375 if (num != 2)
376 return -ENODEV;
377 *handle = acpi_get_pci_rootbridge_handle(seg, bus);
378 if (!*handle)
379 return -ENODEV;
380 return 0;
381}
382
Muthu Kumar9c273b92006-04-28 00:42:21 -0700383static struct acpi_bus_type acpi_pci_bus = {
David Shaohua Li84df749f2005-03-18 18:53:36 -0500384 .bus = &pci_bus_type,
Muthu Kumar9c273b92006-04-28 00:42:21 -0700385 .find_device = acpi_pci_find_device,
386 .find_bridge = acpi_pci_find_root_bridge,
David Shaohua Li84df749f2005-03-18 18:53:36 -0500387};
388
Muthu Kumar9c273b92006-04-28 00:42:21 -0700389static int __init acpi_pci_init(void)
David Shaohua Li84df749f2005-03-18 18:53:36 -0500390{
391 int ret;
392
Shaohua Lif8993af2007-04-25 11:05:12 +0800393 if (acpi_gbl_FADT.boot_flags & BAF_MSI_NOT_SUPPORTED) {
394 printk(KERN_INFO"ACPI FADT declares the system doesn't support MSI, so disable it\n");
395 pci_no_msi();
396 }
Muthu Kumar9c273b92006-04-28 00:42:21 -0700397 ret = register_acpi_bus_type(&acpi_pci_bus);
David Shaohua Li84df749f2005-03-18 18:53:36 -0500398 if (ret)
399 return 0;
Len Brown673d5b42007-07-28 03:33:16 -0400400#ifdef CONFIG_ACPI_SLEEP
David Shaohua Li0f644742005-03-19 00:15:48 -0500401 platform_pci_choose_state = acpi_pci_choose_state;
Len Brown673d5b42007-07-28 03:33:16 -0400402#endif
David Shaohua Lib9131002005-03-19 00:16:18 -0500403 platform_pci_set_power_state = acpi_pci_set_power_state;
David Shaohua Li84df749f2005-03-18 18:53:36 -0500404 return 0;
405}
Muthu Kumar9c273b92006-04-28 00:42:21 -0700406arch_initcall(acpi_pci_init);