PCI: Speed up device reset function
[linux-2.6.git] / drivers / pci / pci-acpi.c
1 /*
2  * File:        pci-acpi.c
3  * Purpose:     Provide PCI support in ACPI
4  *
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.
8  */
9
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>
17
18 #include <linux/pci-acpi.h>
19 #include "pci.h"
20
21 struct acpi_osc_data {
22         acpi_handle handle;
23         u32 support_set;
24         u32 control_set;
25         u32 control_query;
26         int is_queried;
27         struct list_head sibiling;
28 };
29 static LIST_HEAD(acpi_osc_data_list);
30
31 struct acpi_osc_args {
32         u32 capbuf[3];
33 };
34
35 static DEFINE_MUTEX(pci_acpi_lock);
36
37 static 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
54 static u8 OSC_UUID[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40,
55                           0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66};
56
57 static acpi_status acpi_run_osc(acpi_handle handle,
58                                 struct acpi_osc_args *osc_args, u32 *retval)
59 {
60         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;
65         u32 errors, flags = osc_args->capbuf[OSC_QUERY_TYPE];
66
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;
79         in_params[3].buffer.pointer     = (u8 *)osc_args->capbuf;
80
81         status = acpi_evaluate_object(handle, "_OSC", &input, &output);
82         if (ACPI_FAILURE(status))
83                 return status;
84
85         if (!output.length)
86                 return AE_NULL_OBJECT;
87
88         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         }
94         /* 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)
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)
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         }
113 out_success:
114         *retval = *((u32 *)(out_obj->buffer.pointer + 8));
115         status = AE_OK;
116
117 out_kfree:
118         kfree(output.pointer);
119         return status;
120 }
121
122 static acpi_status __acpi_query_osc(u32 flags, struct acpi_osc_data *osc_data)
123 {
124         acpi_status status;
125         u32 support_set, result;
126         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
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;
139         }
140
141         return status;
142 }
143
144 /*
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  */
150 int pci_acpi_osc_support(acpi_handle handle, u32 flags)
151 {
152         acpi_status status;
153         acpi_handle tmp;
154         struct acpi_osc_data *osc_data;
155         int rc = 0;
156
157         status = acpi_get_handle(handle, "_OSC", &tmp);
158         if (ACPI_FAILURE(status))
159                 return -ENOTTY;
160
161         mutex_lock(&pci_acpi_lock);
162         osc_data = acpi_get_osc_data(handle);
163         if (!osc_data) {
164                 printk(KERN_ERR "acpi osc data array is full\n");
165                 rc = -ENOMEM;
166                 goto out;
167         }
168
169         __acpi_query_osc(flags, osc_data);
170 out:
171         mutex_unlock(&pci_acpi_lock);
172         return rc;
173 }
174
175 /**
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
179  *
180  * Attempt to take control from Firmware on requested control bits.
181  **/
182 acpi_status pci_osc_control_set(acpi_handle handle, u32 flags)
183 {
184         acpi_status status;
185         u32 control_req, control_set, result;
186         acpi_handle tmp;
187         struct acpi_osc_data *osc_data;
188         struct acpi_osc_args osc_args;
189
190         status = acpi_get_handle(handle, "_OSC", &tmp);
191         if (ACPI_FAILURE(status))
192                 return status;
193
194         mutex_lock(&pci_acpi_lock);
195         osc_data = acpi_get_osc_data(handle);
196         if (!osc_data) {
197                 printk(KERN_ERR "acpi osc data array is full\n");
198                 status = AE_ERROR;
199                 goto out;
200         }
201
202         control_req = (flags & OSC_CONTROL_MASKS);
203         if (!control_req) {
204                 status = AE_TYPE;
205                 goto out;
206         }
207
208         /* No need to evaluate _OSC if the control was already granted. */
209         if ((osc_data->control_set & control_req) == control_req)
210                 goto out;
211
212         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         }
217
218         if ((osc_data->control_query & control_req) != control_req) {
219                 status = AE_SUPPORT;
220                 goto out;
221         }
222
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;
230 out:
231         mutex_unlock(&pci_acpi_lock);
232         return status;
233 }
234 EXPORT_SYMBOL(pci_osc_control_set);
235
236 /*
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
257  */
258
259 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
260 {
261         int acpi_state;
262
263         acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL);
264         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;
278 }
279
280 static 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 }
286
287 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
288 {
289         acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
290         acpi_handle tmp;
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
297         };
298         int error = -EINVAL;
299
300         /* If the ACPI device has _EJ0, ignore the device */
301         if (!handle || ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
302                 return -ENODEV;
303
304         switch (state) {
305         case PCI_D0:
306         case PCI_D1:
307         case PCI_D2:
308         case PCI_D3hot:
309         case PCI_D3cold:
310                 error = acpi_bus_set_power(handle, state_conv[state]);
311         }
312
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;
318 }
319
320 static 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
327 static 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
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,
344 };
345
346 /* ACPI bus type */
347 static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
348 {
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
361 static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
362 {
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          */
370         num = sscanf(dev_name(dev), "pci%04x:%02x", &seg, &bus);
371         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
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,
383 };
384
385 static int __init acpi_pci_init(void)
386 {
387         int ret;
388
389         if (acpi_gbl_FADT.boot_flags & BAF_MSI_NOT_SUPPORTED) {
390                 printk(KERN_INFO"ACPI FADT declares the system doesn't support MSI, so disable it\n");
391                 pci_no_msi();
392         }
393
394         if (acpi_gbl_FADT.boot_flags & BAF_PCIE_ASPM_CONTROL) {
395                 printk(KERN_INFO"ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
396                 pcie_no_aspm();
397         }
398
399         ret = register_acpi_bus_type(&acpi_pci_bus);
400         if (ret)
401                 return 0;
402         pci_set_platform_pm(&acpi_pci_platform_pm);
403         return 0;
404 }
405 arch_initcall(acpi_pci_init);