[deliverable/linux.git] / drivers / pci / pci-acpi.c

/*
 * File:	pci-acpi.c
 * Purpose:	Provide PCI support in ACPI
 *
 * Copyright (C) 2005 David Shaohua Li <shaohua.li@intel.com>
 * Copyright (C) 2004 Tom Long Nguyen <tom.l.nguyen@intel.com>
 * Copyright (C) 2004 Intel Corp.
 */

#include <linux/delay.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/module.h>
#include <acpi/acpi.h>
#include <acpi/acnamesp.h>
#include <acpi/acresrc.h>
#include <acpi/acpi_bus.h>

#include <linux/pci-acpi.h>
#include "pci.h"

static u32 ctrlset_buf[3] = {0, 0, 0};
static u32 global_ctrlsets = 0;
static u8 OSC_UUID[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40, 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66};

static acpi_status  
acpi_query_osc (
	acpi_handle	handle,
	u32		level,
	void		*context,
	void		**retval )
{
	acpi_status		status;
	struct acpi_object_list	input;
	union acpi_object 	in_params[4];
	struct acpi_buffer	output = {ACPI_ALLOCATE_BUFFER, NULL};
	union acpi_object 	*out_obj;
	u32			osc_dw0;

	
	/* Setting up input parameters */
	input.count = 4;
	input.pointer = in_params;
	in_params[0].type 		= ACPI_TYPE_BUFFER;
	in_params[0].buffer.length 	= 16;
	in_params[0].buffer.pointer	= OSC_UUID;
	in_params[1].type 		= ACPI_TYPE_INTEGER;
	in_params[1].integer.value 	= 1;
	in_params[2].type 		= ACPI_TYPE_INTEGER;
	in_params[2].integer.value	= 3;
	in_params[3].type		= ACPI_TYPE_BUFFER;
	in_params[3].buffer.length 	= 12;
	in_params[3].buffer.pointer 	= (u8 *)context;

	status = acpi_evaluate_object(handle, "_OSC", &input, &output);
	if (ACPI_FAILURE (status)) {
		printk(KERN_DEBUG  
			"Evaluate _OSC Set fails. Status = 0x%04x\n", status);
		return status;
	}
	out_obj = output.pointer;

	if (out_obj->type != ACPI_TYPE_BUFFER) {
		printk(KERN_DEBUG  
			"Evaluate _OSC returns wrong type\n");
		status = AE_TYPE;
		goto query_osc_out;
	}
	osc_dw0 = *((u32 *) out_obj->buffer.pointer);
	if (osc_dw0) {
		if (osc_dw0 & OSC_REQUEST_ERROR)
			printk(KERN_DEBUG "_OSC request fails\n"); 
		if (osc_dw0 & OSC_INVALID_UUID_ERROR)
			printk(KERN_DEBUG "_OSC invalid UUID\n"); 
		if (osc_dw0 & OSC_INVALID_REVISION_ERROR)
			printk(KERN_DEBUG "_OSC invalid revision\n"); 
		if (osc_dw0 & OSC_CAPABILITIES_MASK_ERROR) {
			/* Update Global Control Set */
			global_ctrlsets = *((u32 *)(out_obj->buffer.pointer+8));
			status = AE_OK;
			goto query_osc_out;
		}
		status = AE_ERROR;
		goto query_osc_out;
	}

	/* Update Global Control Set */
	global_ctrlsets = *((u32 *)(out_obj->buffer.pointer + 8));
	status = AE_OK;

query_osc_out:
	kfree(output.pointer);
	return status;
}


static acpi_status  
acpi_run_osc (
	acpi_handle	handle,
	void		*context)
{
	acpi_status		status;
	struct acpi_object_list	input;
	union acpi_object 	in_params[4];
	struct acpi_buffer	output = {ACPI_ALLOCATE_BUFFER, NULL};
	union acpi_object 	*out_obj;
	u32			osc_dw0;

	/* Setting up input parameters */
	input.count = 4;
	input.pointer = in_params;
	in_params[0].type 		= ACPI_TYPE_BUFFER;
	in_params[0].buffer.length 	= 16;
	in_params[0].buffer.pointer	= OSC_UUID;
	in_params[1].type 		= ACPI_TYPE_INTEGER;
	in_params[1].integer.value 	= 1;
	in_params[2].type 		= ACPI_TYPE_INTEGER;
	in_params[2].integer.value	= 3;
	in_params[3].type		= ACPI_TYPE_BUFFER;
	in_params[3].buffer.length 	= 12;
	in_params[3].buffer.pointer 	= (u8 *)context;

	status = acpi_evaluate_object(handle, "_OSC", &input, &output);
	if (ACPI_FAILURE (status)) {
		printk(KERN_DEBUG  
			"Evaluate _OSC Set fails. Status = 0x%04x\n", status);
		return status;
	}
	out_obj = output.pointer;
	if (out_obj->type != ACPI_TYPE_BUFFER) {
		printk(KERN_DEBUG  
			"Evaluate _OSC returns wrong type\n");
		status = AE_TYPE;
		goto run_osc_out;
	}
	osc_dw0 = *((u32 *) out_obj->buffer.pointer);
	if (osc_dw0) {
		if (osc_dw0 & OSC_REQUEST_ERROR)
			printk(KERN_DEBUG "_OSC request fails\n"); 
		if (osc_dw0 & OSC_INVALID_UUID_ERROR)
			printk(KERN_DEBUG "_OSC invalid UUID\n"); 
		if (osc_dw0 & OSC_INVALID_REVISION_ERROR)
			printk(KERN_DEBUG "_OSC invalid revision\n"); 
		if (osc_dw0 & OSC_CAPABILITIES_MASK_ERROR) {
			printk(KERN_DEBUG "_OSC FW not grant req. control\n");
			status = AE_SUPPORT;
			goto run_osc_out;
		}
		status = AE_ERROR;
		goto run_osc_out;
	}
	status = AE_OK;

run_osc_out:
	kfree(output.pointer);
	return status;
}

/**
 * pci_osc_support_set - register OS support to Firmware
 * @flags: OS support bits
 *
 * Update OS support fields and doing a _OSC Query to obtain an update
 * from Firmware on supported control bits.
 **/
acpi_status pci_osc_support_set(u32 flags)
{
	u32 temp;

	if (!(flags & OSC_SUPPORT_MASKS)) {
		return AE_TYPE;
	}
	ctrlset_buf[OSC_SUPPORT_TYPE] |= (flags & OSC_SUPPORT_MASKS);

	/* do _OSC query for all possible controls */
	temp = ctrlset_buf[OSC_CONTROL_TYPE];
	ctrlset_buf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
	ctrlset_buf[OSC_CONTROL_TYPE] = OSC_CONTROL_MASKS;
	acpi_get_devices ( PCI_ROOT_HID_STRING,
			acpi_query_osc,
			ctrlset_buf,
			NULL );
	ctrlset_buf[OSC_QUERY_TYPE] = !OSC_QUERY_ENABLE;
	ctrlset_buf[OSC_CONTROL_TYPE] = temp;
	return AE_OK;
}
EXPORT_SYMBOL(pci_osc_support_set);

/**
 * pci_osc_control_set - commit requested control to Firmware
 * @handle: acpi_handle for the target ACPI object
 * @flags: driver's requested control bits
 *
 * Attempt to take control from Firmware on requested control bits.
 **/
acpi_status pci_osc_control_set(acpi_handle handle, u32 flags)
{
	acpi_status	status;
	u32		ctrlset;

	ctrlset = (flags & OSC_CONTROL_MASKS);
	if (!ctrlset) {
		return AE_TYPE;
	}
	if (ctrlset_buf[OSC_SUPPORT_TYPE] && 
	 	((global_ctrlsets & ctrlset) != ctrlset)) {
		return AE_SUPPORT;
	}
	ctrlset_buf[OSC_CONTROL_TYPE] |= ctrlset;
	status = acpi_run_osc(handle, ctrlset_buf);
	if (ACPI_FAILURE (status)) {
		ctrlset_buf[OSC_CONTROL_TYPE] &= ~ctrlset;
	}
	
	return status;
}
EXPORT_SYMBOL(pci_osc_control_set);

/*
 * _SxD returns the D-state with the highest power
 * (lowest D-state number) supported in the S-state "x".
 *
 * If the devices does not have a _PRW
 * (Power Resources for Wake) supporting system wakeup from "x"
 * then the OS is free to choose a lower power (higher number
 * D-state) than the return value from _SxD.
 *
 * But if _PRW is enabled at S-state "x", the OS
 * must not choose a power lower than _SxD --
 * unless the device has an _SxW method specifying
 * the lowest power (highest D-state number) the device
 * may enter while still able to wake the system.
 *
 * ie. depending on global OS policy:
 *
 * if (_PRW at S-state x)
 *	choose from highest power _SxD to lowest power _SxW
 * else // no _PRW at S-state x
 * 	choose highest power _SxD or any lower power
 *
 * currently we simply return _SxD, if present.
 */

static int acpi_pci_choose_state(struct pci_dev *pdev, pm_message_t state)
{
	/* TBD */

	return -ENODEV;
}

static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
{
	acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
	static int state_conv[] = {
		[0] = 0,
		[1] = 1,
		[2] = 2,
		[3] = 3,
		[4] = 3
	};
	int acpi_state = state_conv[(int __force) state];

	if (!handle)
		return -ENODEV;
	return acpi_bus_set_power(handle, acpi_state);
}


/* ACPI bus type */
static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
{
	struct pci_dev * pci_dev;
	acpi_integer	addr;

	pci_dev = to_pci_dev(dev);
	/* Please ref to ACPI spec for the syntax of _ADR */
	addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
	*handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr);
	if (!*handle)
		return -ENODEV;
	return 0;
}

static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
{
	int num;
	unsigned int seg, bus;

	/*
	 * The string should be the same as root bridge's name
	 * Please look at 'pci_scan_bus_parented'
	 */
	num = sscanf(dev->bus_id, "pci%04x:%02x", &seg, &bus);
	if (num != 2)
		return -ENODEV;
	*handle = acpi_get_pci_rootbridge_handle(seg, bus);
	if (!*handle)
		return -ENODEV;
	return 0;
}

static struct acpi_bus_type acpi_pci_bus = {
	.bus = &pci_bus_type,
	.find_device = acpi_pci_find_device,
	.find_bridge = acpi_pci_find_root_bridge,
};

static int __init acpi_pci_init(void)
{
	int ret;

	ret = register_acpi_bus_type(&acpi_pci_bus);
	if (ret)
		return 0;
	platform_pci_choose_state = acpi_pci_choose_state;
	platform_pci_set_power_state = acpi_pci_set_power_state;
	return 0;
}
arch_initcall(acpi_pci_init);
Commit	Line	Data
1da177e4 LT	1	/*
1da177e4 LT	2	* File: pci-acpi.c
a406d9e6	3	* Purpose: Provide PCI support in ACPI
1da177e4	4	*
84df749f DSL	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.
1da177e4 LT	8	*/
	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>
0f64474b	20	#include "pci.h"
1da177e4 LT	21
	22	static u32 ctrlset_buf[3] = {0, 0, 0};
	23	static u32 global_ctrlsets = 0;
bc56b9e0	24	static u8 OSC_UUID[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40, 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66};
1da177e4 LT	25
	26	static acpi_status
	27	acpi_query_osc (
	28	acpi_handle handle,
	29	u32 level,
	30	void *context,
	31	void **retval )
	32	{
	33	acpi_status status;
	34	struct acpi_object_list input;
	35	union acpi_object in_params[4];
593ee207 KA	36	struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
593ee207 KA	37	union acpi_object *out_obj;
1da177e4 LT	38	u32 osc_dw0;
1da177e4 LT	39
1da177e4 LT	40
	41	/* Setting up input parameters */
	42	input.count = 4;
	43	input.pointer = in_params;
	44	in_params[0].type = ACPI_TYPE_BUFFER;
	45	in_params[0].buffer.length = 16;
	46	in_params[0].buffer.pointer = OSC_UUID;
	47	in_params[1].type = ACPI_TYPE_INTEGER;
	48	in_params[1].integer.value = 1;
	49	in_params[2].type = ACPI_TYPE_INTEGER;
	50	in_params[2].integer.value = 3;
	51	in_params[3].type = ACPI_TYPE_BUFFER;
	52	in_params[3].buffer.length = 12;
	53	in_params[3].buffer.pointer = (u8 *)context;
	54
	55	status = acpi_evaluate_object(handle, "_OSC", &input, &output);
	56	if (ACPI_FAILURE (status)) {
	57	printk(KERN_DEBUG
	58	"Evaluate _OSC Set fails. Status = 0x%04x\n", status);
	59	return status;
	60	}
593ee207 KA	61	out_obj = output.pointer;
	62
	63	if (out_obj->type != ACPI_TYPE_BUFFER) {
1da177e4 LT	64	printk(KERN_DEBUG
1da177e4 LT	65	"Evaluate _OSC returns wrong type\n");
593ee207 KA	66	status = AE_TYPE;
593ee207 KA	67	goto query_osc_out;
1da177e4	68	}
593ee207	69	osc_dw0 = ((u32 ) out_obj->buffer.pointer);
1da177e4 LT	70	if (osc_dw0) {
	71	if (osc_dw0 & OSC_REQUEST_ERROR)
	72	printk(KERN_DEBUG "_OSC request fails\n");
	73	if (osc_dw0 & OSC_INVALID_UUID_ERROR)
	74	printk(KERN_DEBUG "_OSC invalid UUID\n");
	75	if (osc_dw0 & OSC_INVALID_REVISION_ERROR)
	76	printk(KERN_DEBUG "_OSC invalid revision\n");
	77	if (osc_dw0 & OSC_CAPABILITIES_MASK_ERROR) {
	78	/* Update Global Control Set */
593ee207 KA	79	global_ctrlsets = ((u32 )(out_obj->buffer.pointer+8));
	80	status = AE_OK;
	81	goto query_osc_out;
1da177e4	82	}
593ee207 KA	83	status = AE_ERROR;
593ee207 KA	84	goto query_osc_out;
1da177e4 LT	85	}
	86
	87	/* Update Global Control Set */
593ee207 KA	88	global_ctrlsets = ((u32 )(out_obj->buffer.pointer + 8));
	89	status = AE_OK;
	90
	91	query_osc_out:
	92	kfree(output.pointer);
	93	return status;
1da177e4 LT	94	}
	95
	96
	97	static acpi_status
	98	acpi_run_osc (
	99	acpi_handle handle,
427bf532	100	void *context)
1da177e4 LT	101	{
	102	acpi_status status;
	103	struct acpi_object_list input;
	104	union acpi_object in_params[4];
593ee207 KA	105	struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
593ee207 KA	106	union acpi_object *out_obj;
1da177e4 LT	107	u32 osc_dw0;
1da177e4 LT	108
1da177e4 LT	109	/* Setting up input parameters */
	110	input.count = 4;
	111	input.pointer = in_params;
	112	in_params[0].type = ACPI_TYPE_BUFFER;
	113	in_params[0].buffer.length = 16;
	114	in_params[0].buffer.pointer = OSC_UUID;
	115	in_params[1].type = ACPI_TYPE_INTEGER;
	116	in_params[1].integer.value = 1;
	117	in_params[2].type = ACPI_TYPE_INTEGER;
	118	in_params[2].integer.value = 3;
	119	in_params[3].type = ACPI_TYPE_BUFFER;
	120	in_params[3].buffer.length = 12;
	121	in_params[3].buffer.pointer = (u8 *)context;
	122
	123	status = acpi_evaluate_object(handle, "_OSC", &input, &output);
	124	if (ACPI_FAILURE (status)) {
	125	printk(KERN_DEBUG
	126	"Evaluate _OSC Set fails. Status = 0x%04x\n", status);
	127	return status;
	128	}
593ee207 KA	129	out_obj = output.pointer;
593ee207 KA	130	if (out_obj->type != ACPI_TYPE_BUFFER) {
1da177e4 LT	131	printk(KERN_DEBUG
1da177e4 LT	132	"Evaluate _OSC returns wrong type\n");
593ee207 KA	133	status = AE_TYPE;
593ee207 KA	134	goto run_osc_out;
1da177e4	135	}
593ee207	136	osc_dw0 = ((u32 ) out_obj->buffer.pointer);
1da177e4 LT	137	if (osc_dw0) {
	138	if (osc_dw0 & OSC_REQUEST_ERROR)
	139	printk(KERN_DEBUG "_OSC request fails\n");
	140	if (osc_dw0 & OSC_INVALID_UUID_ERROR)
	141	printk(KERN_DEBUG "_OSC invalid UUID\n");
	142	if (osc_dw0 & OSC_INVALID_REVISION_ERROR)
	143	printk(KERN_DEBUG "_OSC invalid revision\n");
	144	if (osc_dw0 & OSC_CAPABILITIES_MASK_ERROR) {
	145	printk(KERN_DEBUG "_OSC FW not grant req. control\n");
593ee207 KA	146	status = AE_SUPPORT;
593ee207 KA	147	goto run_osc_out;
1da177e4	148	}
593ee207 KA	149	status = AE_ERROR;
593ee207 KA	150	goto run_osc_out;
1da177e4	151	}
593ee207 KA	152	status = AE_OK;
	153
	154	run_osc_out:
	155	kfree(output.pointer);
	156	return status;
1da177e4 LT	157	}
	158
	159	/**
	160	* pci_osc_support_set - register OS support to Firmware
	161	* @flags: OS support bits
	162	*
	163	* Update OS support fields and doing a _OSC Query to obtain an update
	164	* from Firmware on supported control bits.
	165	**/
	166	acpi_status pci_osc_support_set(u32 flags)
	167	{
	168	u32 temp;
	169
	170	if (!(flags & OSC_SUPPORT_MASKS)) {
	171	return AE_TYPE;
	172	}
	173	ctrlset_buf[OSC_SUPPORT_TYPE] \|= (flags & OSC_SUPPORT_MASKS);
	174
	175	/* do _OSC query for all possible controls */
	176	temp = ctrlset_buf[OSC_CONTROL_TYPE];
	177	ctrlset_buf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
	178	ctrlset_buf[OSC_CONTROL_TYPE] = OSC_CONTROL_MASKS;
	179	acpi_get_devices ( PCI_ROOT_HID_STRING,
	180	acpi_query_osc,
	181	ctrlset_buf,
	182	NULL );
	183	ctrlset_buf[OSC_QUERY_TYPE] = !OSC_QUERY_ENABLE;
	184	ctrlset_buf[OSC_CONTROL_TYPE] = temp;
	185	return AE_OK;
	186	}
	187	EXPORT_SYMBOL(pci_osc_support_set);
	188
	189	/**
	190	* pci_osc_control_set - commit requested control to Firmware
f366633f	191	* @handle: acpi_handle for the target ACPI object
1da177e4 LT	192	* @flags: driver's requested control bits
	193	*
	194	* Attempt to take control from Firmware on requested control bits.
	195	**/
427bf532	196	acpi_status pci_osc_control_set(acpi_handle handle, u32 flags)
1da177e4 LT	197	{
	198	acpi_status status;
	199	u32 ctrlset;
	200
	201	ctrlset = (flags & OSC_CONTROL_MASKS);
	202	if (!ctrlset) {
	203	return AE_TYPE;
	204	}
	205	if (ctrlset_buf[OSC_SUPPORT_TYPE] &&
	206	((global_ctrlsets & ctrlset) != ctrlset)) {
	207	return AE_SUPPORT;
	208	}
	209	ctrlset_buf[OSC_CONTROL_TYPE] \|= ctrlset;
427bf532	210	status = acpi_run_osc(handle, ctrlset_buf);
1da177e4 LT	211	if (ACPI_FAILURE (status)) {
	212	ctrlset_buf[OSC_CONTROL_TYPE] &= ~ctrlset;
	213	}
	214
	215	return status;
	216	}
	217	EXPORT_SYMBOL(pci_osc_control_set);
84df749f	218
0f64474b DSL	219	/*
	220	* _SxD returns the D-state with the highest power
	221	* (lowest D-state number) supported in the S-state "x".
	222	*
	223	* If the devices does not have a _PRW
	224	* (Power Resources for Wake) supporting system wakeup from "x"
	225	* then the OS is free to choose a lower power (higher number
	226	* D-state) than the return value from _SxD.
	227	*
	228	* But if _PRW is enabled at S-state "x", the OS
	229	* must not choose a power lower than _SxD --
	230	* unless the device has an _SxW method specifying
	231	* the lowest power (highest D-state number) the device
	232	* may enter while still able to wake the system.
	233	*
	234	* ie. depending on global OS policy:
	235	*
	236	* if (_PRW at S-state x)
	237	* choose from highest power _SxD to lowest power _SxW
	238	* else // no _PRW at S-state x
	239	* choose highest power _SxD or any lower power
	240	*
	241	* currently we simply return _SxD, if present.
	242	*/
	243
	244	static int acpi_pci_choose_state(struct pci_dev *pdev, pm_message_t state)
	245	{
a406d9e6	246	/* TBD */
0f64474b	247
0f64474b DSL	248	return -ENODEV;
	249	}
	250
b913100d DSL	251	static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
	252	{
	253	acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
	254	static int state_conv[] = {
	255	[0] = 0,
	256	[1] = 1,
	257	[2] = 2,
	258	[3] = 3,
	259	[4] = 3
	260	};
	261	int acpi_state = state_conv[(int __force) state];
	262
	263	if (!handle)
	264	return -ENODEV;
	265	return acpi_bus_set_power(handle, acpi_state);
	266	}
	267
	268
84df749f	269	/* ACPI bus type */
9c273b95	270	static int acpi_pci_find_device(struct device dev, acpi_handle handle)
84df749f DSL	271	{
	272	struct pci_dev * pci_dev;
	273	acpi_integer addr;
	274
	275	pci_dev = to_pci_dev(dev);
	276	/* Please ref to ACPI spec for the syntax of _ADR */
	277	addr = (PCI_SLOT(pci_dev->devfn) << 16) \| PCI_FUNC(pci_dev->devfn);
	278	*handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr);
	279	if (!*handle)
	280	return -ENODEV;
	281	return 0;
	282	}
	283
9c273b95	284	static int acpi_pci_find_root_bridge(struct device dev, acpi_handle handle)
84df749f DSL	285	{
	286	int num;
	287	unsigned int seg, bus;
	288
	289	/*
	290	* The string should be the same as root bridge's name
	291	* Please look at 'pci_scan_bus_parented'
	292	*/
	293	num = sscanf(dev->bus_id, "pci%04x:%02x", &seg, &bus);
	294	if (num != 2)
	295	return -ENODEV;
	296	*handle = acpi_get_pci_rootbridge_handle(seg, bus);
	297	if (!*handle)
	298	return -ENODEV;
	299	return 0;
	300	}
	301
9c273b95	302	static struct acpi_bus_type acpi_pci_bus = {
84df749f	303	.bus = &pci_bus_type,
9c273b95 MK	304	.find_device = acpi_pci_find_device,
9c273b95 MK	305	.find_bridge = acpi_pci_find_root_bridge,
84df749f DSL	306	};
84df749f DSL	307
9c273b95	308	static int __init acpi_pci_init(void)
84df749f DSL	309	{
	310	int ret;
	311
9c273b95	312	ret = register_acpi_bus_type(&acpi_pci_bus);
84df749f DSL	313	if (ret)
84df749f DSL	314	return 0;
0f64474b	315	platform_pci_choose_state = acpi_pci_choose_state;
b913100d	316	platform_pci_set_power_state = acpi_pci_set_power_state;
84df749f DSL	317	return 0;
84df749f DSL	318	}
9c273b95	319	arch_initcall(acpi_pci_init);