WAN: convert drivers to use built-in netdev_stats
[linux-2.6] / 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 <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>
20 #include "pci.h"
21
22 struct acpi_osc_data {
23         acpi_handle handle;
24         u32 ctrlset_buf[3];
25         u32 global_ctrlsets;
26         struct list_head sibiling;
27 };
28 static LIST_HEAD(acpi_osc_data_list);
29
30 static 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
47 static u8 OSC_UUID[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40, 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66};
48
49 static acpi_status  
50 acpi_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];
59         struct acpi_buffer      output = {ACPI_ALLOCATE_BUFFER, NULL};
60         union acpi_object       *out_obj;
61         u32                     osc_dw0;
62         acpi_status *ret_status = (acpi_status *)retval;
63         struct acpi_osc_data *osc_data;
64         u32 flags = (unsigned long)context, temp;
65         acpi_handle tmp;
66
67         status = acpi_get_handle(handle, "_OSC", &tmp);
68         if (ACPI_FAILURE(status))
69                 return status;
70
71         osc_data = acpi_get_osc_data(handle);
72         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
84         /* 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;
96         in_params[3].buffer.pointer     = (u8 *)osc_data->ctrlset_buf;
97
98         status = acpi_evaluate_object(handle, "_OSC", &input, &output);
99         if (ACPI_FAILURE(status))
100                 goto out_nofree;
101         out_obj = output.pointer;
102
103         if (out_obj->type != ACPI_TYPE_BUFFER) {
104                 printk(KERN_DEBUG  
105                         "Evaluate _OSC returns wrong type\n");
106                 status = AE_TYPE;
107                 goto query_osc_out;
108         }
109         osc_dw0 = *((u32 *) out_obj->buffer.pointer);
110         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 */
119                         osc_data->global_ctrlsets =
120                                 *((u32 *)(out_obj->buffer.pointer + 8));
121                         status = AE_OK;
122                         goto query_osc_out;
123                 }
124                 status = AE_ERROR;
125                 goto query_osc_out;
126         }
127
128         /* Update Global Control Set */
129         osc_data->global_ctrlsets = *((u32 *)(out_obj->buffer.pointer + 8));
130         status = AE_OK;
131
132 query_osc_out:
133         kfree(output.pointer);
134 out_nofree:
135         *ret_status = status;
136
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
144         return status;
145 }
146
147
148 static acpi_status  
149 acpi_run_osc (
150         acpi_handle     handle,
151         void            *context)
152 {
153         acpi_status             status;
154         struct acpi_object_list input;
155         union acpi_object       in_params[4];
156         struct acpi_buffer      output = {ACPI_ALLOCATE_BUFFER, NULL};
157         union acpi_object       *out_obj;
158         u32                     osc_dw0;
159
160         /* 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);
175         if (ACPI_FAILURE (status))
176                 return status;
177
178         out_obj = output.pointer;
179         if (out_obj->type != ACPI_TYPE_BUFFER) {
180                 printk(KERN_DEBUG  
181                         "Evaluate _OSC returns wrong type\n");
182                 status = AE_TYPE;
183                 goto run_osc_out;
184         }
185         osc_dw0 = *((u32 *) out_obj->buffer.pointer);
186         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");
195                         status = AE_SUPPORT;
196                         goto run_osc_out;
197                 }
198                 status = AE_ERROR;
199                 goto run_osc_out;
200         }
201         status = AE_OK;
202
203 run_osc_out:
204         kfree(output.pointer);
205         return status;
206 }
207
208 /**
209  * __pci_osc_support_set - register OS support to Firmware
210  * @flags: OS support bits
211  * @hid: hardware ID
212  *
213  * Update OS support fields and doing a _OSC Query to obtain an update
214  * from Firmware on supported control bits.
215  **/
216 acpi_status __pci_osc_support_set(u32 flags, const char *hid)
217 {
218         acpi_status retval = AE_NOT_FOUND;
219
220         if (!(flags & OSC_SUPPORT_MASKS)) {
221                 return AE_TYPE;
222         }
223         acpi_get_devices(hid,
224                         acpi_query_osc,
225                         (void *)(unsigned long)flags,
226                         (void **) &retval );
227         return AE_OK;
228 }
229
230 /**
231  * pci_osc_control_set - commit requested control to Firmware
232  * @handle: acpi_handle for the target ACPI object
233  * @flags: driver's requested control bits
234  *
235  * Attempt to take control from Firmware on requested control bits.
236  **/
237 acpi_status pci_osc_control_set(acpi_handle handle, u32 flags)
238 {
239         acpi_status     status;
240         u32             ctrlset;
241         acpi_handle tmp;
242         struct acpi_osc_data *osc_data;
243
244         status = acpi_get_handle(handle, "_OSC", &tmp);
245         if (ACPI_FAILURE(status))
246                 return status;
247
248         osc_data = acpi_get_osc_data(handle);
249         if (!osc_data) {
250                 printk(KERN_ERR "acpi osc data array is full\n");
251                 return AE_ERROR;
252         }
253
254         ctrlset = (flags & OSC_CONTROL_MASKS);
255         if (!ctrlset) {
256                 return AE_TYPE;
257         }
258         if (osc_data->ctrlset_buf[OSC_SUPPORT_TYPE] &&
259                 ((osc_data->global_ctrlsets & ctrlset) != ctrlset)) {
260                 return AE_SUPPORT;
261         }
262         osc_data->ctrlset_buf[OSC_CONTROL_TYPE] |= ctrlset;
263         status = acpi_run_osc(handle, osc_data->ctrlset_buf);
264         if (ACPI_FAILURE (status)) {
265                 osc_data->ctrlset_buf[OSC_CONTROL_TYPE] &= ~ctrlset;
266         }
267         
268         return status;
269 }
270 EXPORT_SYMBOL(pci_osc_control_set);
271
272 #ifdef CONFIG_ACPI_SLEEP
273 /*
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
294  */
295
296 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev,
297         pm_message_t state)
298 {
299         int acpi_state;
300
301         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;
317 }
318
319 static int acpi_platform_enable_wakeup(struct device *dev, int is_on)
320 {
321         struct acpi_device      *adev;
322         int                     status;
323
324         if (!device_can_wakeup(dev))
325                 return -EINVAL;
326
327         if (is_on && !device_may_wakeup(dev))
328                 return -EINVAL;
329
330         status = acpi_bus_get_device(DEVICE_ACPI_HANDLE(dev), &adev);
331         if (status < 0)
332                 return status;
333
334         adev->wakeup.state.enabled = !!is_on;
335         return 0;
336 }
337 #endif
338
339 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
340 {
341         acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
342         acpi_handle tmp;
343         static const u8 state_conv[] = {
344                 [PCI_D0] = ACPI_STATE_D0,
345                 [PCI_D1] = ACPI_STATE_D1,
346                 [PCI_D2] = ACPI_STATE_D2,
347                 [PCI_D3hot] = ACPI_STATE_D3,
348                 [PCI_D3cold] = ACPI_STATE_D3
349         };
350
351         if (!handle)
352                 return -ENODEV;
353         /* If the ACPI device has _EJ0, ignore the device */
354         if (ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
355                 return 0;
356
357         switch (state) {
358         case PCI_D0:
359         case PCI_D1:
360         case PCI_D2:
361         case PCI_D3hot:
362         case PCI_D3cold:
363                 return acpi_bus_set_power(handle, state_conv[state]);
364         }
365         return -EINVAL;
366 }
367
368
369 /* ACPI bus type */
370 static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
371 {
372         struct pci_dev * pci_dev;
373         acpi_integer    addr;
374
375         pci_dev = to_pci_dev(dev);
376         /* Please ref to ACPI spec for the syntax of _ADR */
377         addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
378         *handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr);
379         if (!*handle)
380                 return -ENODEV;
381         return 0;
382 }
383
384 static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
385 {
386         int num;
387         unsigned int seg, bus;
388
389         /*
390          * The string should be the same as root bridge's name
391          * Please look at 'pci_scan_bus_parented'
392          */
393         num = sscanf(dev->bus_id, "pci%04x:%02x", &seg, &bus);
394         if (num != 2)
395                 return -ENODEV;
396         *handle = acpi_get_pci_rootbridge_handle(seg, bus);
397         if (!*handle)
398                 return -ENODEV;
399         return 0;
400 }
401
402 static struct acpi_bus_type acpi_pci_bus = {
403         .bus = &pci_bus_type,
404         .find_device = acpi_pci_find_device,
405         .find_bridge = acpi_pci_find_root_bridge,
406 };
407
408 static int __init acpi_pci_init(void)
409 {
410         int ret;
411
412         if (acpi_gbl_FADT.boot_flags & BAF_MSI_NOT_SUPPORTED) {
413                 printk(KERN_INFO"ACPI FADT declares the system doesn't support MSI, so disable it\n");
414                 pci_no_msi();
415         }
416         ret = register_acpi_bus_type(&acpi_pci_bus);
417         if (ret)
418                 return 0;
419 #ifdef  CONFIG_ACPI_SLEEP
420         platform_pci_choose_state = acpi_pci_choose_state;
421         platform_enable_wakeup = acpi_platform_enable_wakeup;
422 #endif
423         platform_pci_set_power_state = acpi_pci_set_power_state;
424         return 0;
425 }
426 arch_initcall(acpi_pci_init);