blob: 368ca72dffbcfc230b2ba3a97a99b3c26106cbc5 [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>
Shaohua Li5fde2442008-07-23 10:32:24 +080014#include <linux/pci-aspm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <acpi/acpi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <acpi/acpi_bus.h>
17
18#include <linux/pci-acpi.h>
David Shaohua Li0f644742005-03-19 00:15:48 -050019#include "pci.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
Shaohua Lia5d1c872008-05-12 10:48:10 +080021struct acpi_osc_data {
22 acpi_handle handle;
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +090023 u32 support_set;
24 u32 control_set;
Taku Izumi86d86982008-11-20 15:22:39 +090025 u32 control_query;
Taku Izumi753e3ac2008-11-20 15:22:32 +090026 int is_queried;
Shaohua Lia5d1c872008-05-12 10:48:10 +080027 struct list_head sibiling;
28};
29static LIST_HEAD(acpi_osc_data_list);
30
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +090031struct acpi_osc_args {
32 u32 capbuf[3];
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +090033};
34
Taku Izumi9778c142008-10-17 13:48:36 +090035static DEFINE_MUTEX(pci_acpi_lock);
36
Shaohua Lia5d1c872008-05-12 10:48:10 +080037static struct acpi_osc_data *acpi_get_osc_data(acpi_handle handle)
38{
39 struct acpi_osc_data *data;
40
41 list_for_each_entry(data, &acpi_osc_data_list, sibiling) {
42 if (data->handle == handle)
43 return data;
44 }
45 data = kzalloc(sizeof(*data), GFP_KERNEL);
46 if (!data)
47 return NULL;
48 INIT_LIST_HEAD(&data->sibiling);
49 data->handle = handle;
50 list_add_tail(&data->sibiling, &acpi_osc_data_list);
51 return data;
52}
53
Kenji Kaneshige90a57da2008-05-15 15:23:13 +090054static u8 OSC_UUID[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40,
55 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66};
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +090057static acpi_status acpi_run_osc(acpi_handle handle,
Taku Izumi86d86982008-11-20 15:22:39 +090058 struct acpi_osc_args *osc_args, u32 *retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059{
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +090060 acpi_status status;
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;
Kenji Kaneshige2485b862008-11-10 13:54:43 +090065 u32 errors, flags = osc_args->capbuf[OSC_QUERY_TYPE];
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +090066
67 /* Setting up input parameters */
68 input.count = 4;
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;
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +090079 in_params[3].buffer.pointer = (u8 *)osc_args->capbuf;
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +090080
81 status = acpi_evaluate_object(handle, "_OSC", &input, &output);
82 if (ACPI_FAILURE(status))
83 return status;
84
Rafael J. Wysockif8123382008-10-24 21:50:31 +020085 if (!output.length)
86 return AE_NULL_OBJECT;
87
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +090088 out_obj = output.pointer;
89 if (out_obj->type != ACPI_TYPE_BUFFER) {
90 printk(KERN_DEBUG "Evaluate _OSC returns wrong type\n");
91 status = AE_TYPE;
92 goto out_kfree;
93 }
Kenji Kaneshige2485b862008-11-10 13:54:43 +090094 /* Need to ignore the bit0 in result code */
95 errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
96 if (errors) {
97 if (errors & OSC_REQUEST_ERROR)
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +090098 printk(KERN_DEBUG "_OSC request fails\n");
Kenji Kaneshige2485b862008-11-10 13:54:43 +090099 if (errors & OSC_INVALID_UUID_ERROR)
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +0900100 printk(KERN_DEBUG "_OSC invalid UUID\n");
Kenji Kaneshige2485b862008-11-10 13:54:43 +0900101 if (errors & OSC_INVALID_REVISION_ERROR)
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +0900102 printk(KERN_DEBUG "_OSC invalid revision\n");
Kenji Kaneshige2485b862008-11-10 13:54:43 +0900103 if (errors & OSC_CAPABILITIES_MASK_ERROR) {
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +0900104 if (flags & OSC_QUERY_ENABLE)
105 goto out_success;
106 printk(KERN_DEBUG "_OSC FW not grant req. control\n");
107 status = AE_SUPPORT;
108 goto out_kfree;
109 }
110 status = AE_ERROR;
111 goto out_kfree;
112 }
113out_success:
Taku Izumi86d86982008-11-20 15:22:39 +0900114 *retval = *((u32 *)(out_obj->buffer.pointer + 8));
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +0900115 status = AE_OK;
116
117out_kfree:
118 kfree(output.pointer);
119 return status;
120}
121
Taku Izumi753e3ac2008-11-20 15:22:32 +0900122static acpi_status __acpi_query_osc(u32 flags, struct acpi_osc_data *osc_data)
Taku Izumi4e394322008-10-17 13:49:46 +0900123{
124 acpi_status status;
Taku Izumi86d86982008-11-20 15:22:39 +0900125 u32 support_set, result;
Taku Izumi4e394322008-10-17 13:49:46 +0900126 struct acpi_osc_args osc_args;
127
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;
133
Taku Izumi86d86982008-11-20 15:22:39 +0900134 status = acpi_run_osc(osc_data->handle, &osc_args, &result);
Taku Izumi4e394322008-10-17 13:49:46 +0900135 if (ACPI_SUCCESS(status)) {
136 osc_data->support_set = support_set;
Taku Izumi86d86982008-11-20 15:22:39 +0900137 osc_data->control_query = result;
Taku Izumi753e3ac2008-11-20 15:22:32 +0900138 osc_data->is_queried = 1;
Taku Izumi4e394322008-10-17 13:49:46 +0900139 }
140
141 return status;
142}
143
Andrew Patterson990a7ac2008-11-10 15:30:45 -0700144/*
145 * pci_acpi_osc_support: Invoke _OSC indicating support for the given feature
146 * @flags: Bitmask of flags to support
147 *
148 * See the ACPI spec for the definition of the flags
149 */
150int pci_acpi_osc_support(acpi_handle handle, u32 flags)
Kenji Kaneshige8a7a4fa2008-05-15 15:18:53 +0900151{
152 acpi_status status;
Kenji Kaneshigec4e5fad2008-05-13 16:48:50 +0900153 acpi_handle tmp;
Andrew Patterson990a7ac2008-11-10 15:30:45 -0700154 struct acpi_osc_data *osc_data;
155 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Kenji Kaneshigec4e5fad2008-05-13 16:48:50 +0900157 status = acpi_get_handle(handle, "_OSC", &tmp);
158 if (ACPI_FAILURE(status))
Andrew Patterson990a7ac2008-11-10 15:30:45 -0700159 return -ENOTTY;
Kenji Kaneshigec4e5fad2008-05-13 16:48:50 +0900160
Taku Izumi9778c142008-10-17 13:48:36 +0900161 mutex_lock(&pci_acpi_lock);
Kenji Kaneshigec4e5fad2008-05-13 16:48:50 +0900162 osc_data = acpi_get_osc_data(handle);
Shaohua Lia5d1c872008-05-12 10:48:10 +0800163 if (!osc_data) {
164 printk(KERN_ERR "acpi osc data array is full\n");
Andrew Patterson990a7ac2008-11-10 15:30:45 -0700165 rc = -ENOMEM;
Taku Izumi9778c142008-10-17 13:48:36 +0900166 goto out;
Shaohua Lia5d1c872008-05-12 10:48:10 +0800167 }
168
Taku Izumi753e3ac2008-11-20 15:22:32 +0900169 __acpi_query_osc(flags, osc_data);
Taku Izumi9778c142008-10-17 13:48:36 +0900170out:
171 mutex_unlock(&pci_acpi_lock);
Andrew Patterson990a7ac2008-11-10 15:30:45 -0700172 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
175/**
176 * pci_osc_control_set - commit requested control to Firmware
Randy Dunlapf3666332005-11-23 15:45:04 -0800177 * @handle: acpi_handle for the target ACPI object
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 * @flags: driver's requested control bits
179 *
180 * Attempt to take control from Firmware on requested control bits.
181 **/
rajesh.shah@intel.com427bf532005-10-31 16:20:11 -0800182acpi_status pci_osc_control_set(acpi_handle handle, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +0900184 acpi_status status;
Taku Izumi86d86982008-11-20 15:22:39 +0900185 u32 control_req, control_set, result;
Kenji Kaneshige34a65052008-05-12 22:55:45 +0900186 acpi_handle tmp;
187 struct acpi_osc_data *osc_data;
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +0900188 struct acpi_osc_args osc_args;
Shaohua Lia5d1c872008-05-12 10:48:10 +0800189
Kenji Kaneshige34a65052008-05-12 22:55:45 +0900190 status = acpi_get_handle(handle, "_OSC", &tmp);
191 if (ACPI_FAILURE(status))
192 return status;
193
Taku Izumi9778c142008-10-17 13:48:36 +0900194 mutex_lock(&pci_acpi_lock);
Kenji Kaneshige34a65052008-05-12 22:55:45 +0900195 osc_data = acpi_get_osc_data(handle);
Shaohua Lia5d1c872008-05-12 10:48:10 +0800196 if (!osc_data) {
197 printk(KERN_ERR "acpi osc data array is full\n");
Taku Izumi9778c142008-10-17 13:48:36 +0900198 status = AE_ERROR;
199 goto out;
Shaohua Lia5d1c872008-05-12 10:48:10 +0800200 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Taku Izumi86d86982008-11-20 15:22:39 +0900202 control_req = (flags & OSC_CONTROL_MASKS);
203 if (!control_req) {
Taku Izumi9778c142008-10-17 13:48:36 +0900204 status = AE_TYPE;
205 goto out;
206 }
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +0900207
Taku Izumie0fa3b42008-11-20 15:22:37 +0900208 /* No need to evaluate _OSC if the control was already granted. */
Taku Izumi86d86982008-11-20 15:22:39 +0900209 if ((osc_data->control_set & control_req) == control_req)
Taku Izumiadf411b2008-10-17 13:51:00 +0900210 goto out;
Taku Izumi4e394322008-10-17 13:49:46 +0900211
Taku Izumi753e3ac2008-11-20 15:22:32 +0900212 if (!osc_data->is_queried) {
213 status = __acpi_query_osc(osc_data->support_set, osc_data);
214 if (ACPI_FAILURE(status))
215 goto out;
216 }
Taku Izumi4e394322008-10-17 13:49:46 +0900217
Taku Izumi86d86982008-11-20 15:22:39 +0900218 if ((osc_data->control_query & control_req) != control_req) {
Taku Izumi9778c142008-10-17 13:48:36 +0900219 status = AE_SUPPORT;
220 goto out;
221 }
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +0900222
Taku Izumi86d86982008-11-20 15:22:39 +0900223 control_set = osc_data->control_set | control_req;
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +0900224 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;
Taku Izumi86d86982008-11-20 15:22:39 +0900227 status = acpi_run_osc(handle, &osc_args, &result);
Kenji Kaneshige5e0b9942008-05-15 15:20:11 +0900228 if (ACPI_SUCCESS(status))
Taku Izumi86d86982008-11-20 15:22:39 +0900229 osc_data->control_set = result;
Taku Izumi9778c142008-10-17 13:48:36 +0900230out:
231 mutex_unlock(&pci_acpi_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return status;
233}
234EXPORT_SYMBOL(pci_osc_control_set);
David Shaohua Li84df749f2005-03-18 18:53:36 -0500235
David Shaohua Li0f644742005-03-19 00:15:48 -0500236/*
237 * _SxD returns the D-state with the highest power
238 * (lowest D-state number) supported in the S-state "x".
239 *
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.
244 *
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.
250 *
251 * ie. depending on global OS policy:
252 *
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
David Shaohua Li0f644742005-03-19 00:15:48 -0500257 */
258
Rafael J. Wysocki8d2bdf42008-06-05 01:16:37 +0200259static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
David Shaohua Li0f644742005-03-19 00:15:48 -0500260{
Shaohua Liab826ca2007-07-20 10:03:22 +0800261 int acpi_state;
David Shaohua Li0f644742005-03-19 00:15:48 -0500262
David Brownell06166782008-06-05 01:15:40 +0200263 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL);
Shaohua Liab826ca2007-07-20 10:03:22 +0800264 if (acpi_state < 0)
265 return PCI_POWER_ERROR;
266
267 switch (acpi_state) {
268 case ACPI_STATE_D0:
269 return PCI_D0;
270 case ACPI_STATE_D1:
271 return PCI_D1;
272 case ACPI_STATE_D2:
273 return PCI_D2;
274 case ACPI_STATE_D3:
275 return PCI_D3hot;
276 }
277 return PCI_POWER_ERROR;
David Shaohua Li0f644742005-03-19 00:15:48 -0500278}
Rafael J. Wysocki961d9122008-07-07 03:32:02 +0200279
280static bool acpi_pci_power_manageable(struct pci_dev *dev)
281{
282 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
283
284 return handle ? acpi_bus_power_manageable(handle) : false;
285}
David Shaohua Li0f644742005-03-19 00:15:48 -0500286
David Shaohua Lib9131002005-03-19 00:16:18 -0500287static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
288{
289 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
Shaohua Li10b3dca2007-07-20 10:03:25 +0800290 acpi_handle tmp;
David Brownell583c3772008-02-22 21:41:51 -0800291 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
David Shaohua Lib9131002005-03-19 00:16:18 -0500297 };
Rafael J. Wysocki44e4e662008-07-07 03:32:52 +0200298 int error = -EINVAL;
David Shaohua Lib9131002005-03-19 00:16:18 -0500299
Shaohua Li10b3dca2007-07-20 10:03:25 +0800300 /* If the ACPI device has _EJ0, ignore the device */
Rafael J. Wysocki44e4e662008-07-07 03:32:52 +0200301 if (!handle || ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
302 return -ENODEV;
David Brownell583c3772008-02-22 21:41:51 -0800303
304 switch (state) {
305 case PCI_D0:
306 case PCI_D1:
307 case PCI_D2:
308 case PCI_D3hot:
309 case PCI_D3cold:
Rafael J. Wysocki44e4e662008-07-07 03:32:52 +0200310 error = acpi_bus_set_power(handle, state_conv[state]);
David Brownell583c3772008-02-22 21:41:51 -0800311 }
Rafael J. Wysocki44e4e662008-07-07 03:32:52 +0200312
313 if (!error)
314 dev_printk(KERN_INFO, &dev->dev,
315 "power state changed by ACPI to D%d\n", state);
316
317 return error;
David Shaohua Lib9131002005-03-19 00:16:18 -0500318}
319
Rafael J. Wysockieb9d0fe2008-07-07 03:34:48 +0200320static bool acpi_pci_can_wakeup(struct pci_dev *dev)
321{
322 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
323
324 return handle ? acpi_bus_can_wakeup(handle) : false;
325}
326
327static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
328{
329 int error = acpi_pm_device_sleep_wake(&dev->dev, enable);
330
331 if (!error)
332 dev_printk(KERN_INFO, &dev->dev,
333 "wake-up capability %s by ACPI\n",
334 enable ? "enabled" : "disabled");
335 return error;
336}
337
Rafael J. Wysocki961d9122008-07-07 03:32:02 +0200338static 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,
Rafael J. Wysockieb9d0fe2008-07-07 03:34:48 +0200342 .can_wakeup = acpi_pci_can_wakeup,
343 .sleep_wake = acpi_pci_sleep_wake,
Rafael J. Wysocki961d9122008-07-07 03:32:02 +0200344};
David Shaohua Lib9131002005-03-19 00:16:18 -0500345
David Shaohua Li84df749f2005-03-18 18:53:36 -0500346/* ACPI bus type */
Muthu Kumar9c273b92006-04-28 00:42:21 -0700347static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
David Shaohua Li84df749f2005-03-18 18:53:36 -0500348{
349 struct pci_dev * pci_dev;
350 acpi_integer addr;
351
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);
356 if (!*handle)
357 return -ENODEV;
358 return 0;
359}
360
Muthu Kumar9c273b92006-04-28 00:42:21 -0700361static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
David Shaohua Li84df749f2005-03-18 18:53:36 -0500362{
363 int num;
364 unsigned int seg, bus;
365
366 /*
367 * The string should be the same as root bridge's name
368 * Please look at 'pci_scan_bus_parented'
369 */
Kay Sievers1a927132008-10-30 02:17:49 +0100370 num = sscanf(dev_name(dev), "pci%04x:%02x", &seg, &bus);
David Shaohua Li84df749f2005-03-18 18:53:36 -0500371 if (num != 2)
372 return -ENODEV;
373 *handle = acpi_get_pci_rootbridge_handle(seg, bus);
374 if (!*handle)
375 return -ENODEV;
376 return 0;
377}
378
Muthu Kumar9c273b92006-04-28 00:42:21 -0700379static struct acpi_bus_type acpi_pci_bus = {
David Shaohua Li84df749f2005-03-18 18:53:36 -0500380 .bus = &pci_bus_type,
Muthu Kumar9c273b92006-04-28 00:42:21 -0700381 .find_device = acpi_pci_find_device,
382 .find_bridge = acpi_pci_find_root_bridge,
David Shaohua Li84df749f2005-03-18 18:53:36 -0500383};
384
Muthu Kumar9c273b92006-04-28 00:42:21 -0700385static int __init acpi_pci_init(void)
David Shaohua Li84df749f2005-03-18 18:53:36 -0500386{
387 int ret;
388
Bob Moore993958f2009-02-03 15:14:33 +0800389 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
Shaohua Lif8993af2007-04-25 11:05:12 +0800390 printk(KERN_INFO"ACPI FADT declares the system doesn't support MSI, so disable it\n");
391 pci_no_msi();
392 }
Shaohua Li5fde2442008-07-23 10:32:24 +0800393
Bob Moore993958f2009-02-03 15:14:33 +0800394 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
Shaohua Li5fde2442008-07-23 10:32:24 +0800395 printk(KERN_INFO"ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
396 pcie_no_aspm();
397 }
398
Muthu Kumar9c273b92006-04-28 00:42:21 -0700399 ret = register_acpi_bus_type(&acpi_pci_bus);
David Shaohua Li84df749f2005-03-18 18:53:36 -0500400 if (ret)
401 return 0;
Rafael J. Wysocki961d9122008-07-07 03:32:02 +0200402 pci_set_platform_pm(&acpi_pci_platform_pm);
David Shaohua Li84df749f2005-03-18 18:53:36 -0500403 return 0;
404}
Muthu Kumar9c273b92006-04-28 00:42:21 -0700405arch_initcall(acpi_pci_init);