PCI / ACPI / PM: Platform support for PCI PME wake-up
[linux-2.6.git] / drivers / acpi / pci_root.c
1 /*
2  *  pci_root.c - ACPI PCI Root Bridge Driver ($Revision: 40 $)
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *
7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or (at
12  *  your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful, but
15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *  General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License along
20  *  with this program; if not, write to the Free Software Foundation, Inc.,
21  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22  *
23  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24  */
25
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/types.h>
30 #include <linux/proc_fs.h>
31 #include <linux/spinlock.h>
32 #include <linux/pm.h>
33 #include <linux/pm_runtime.h>
34 #include <linux/pci.h>
35 #include <linux/pci-acpi.h>
36 #include <linux/acpi.h>
37 #include <acpi/acpi_bus.h>
38 #include <acpi/acpi_drivers.h>
39
40 #define PREFIX "ACPI: "
41
42 #define _COMPONENT              ACPI_PCI_COMPONENT
43 ACPI_MODULE_NAME("pci_root");
44 #define ACPI_PCI_ROOT_CLASS             "pci_bridge"
45 #define ACPI_PCI_ROOT_DEVICE_NAME       "PCI Root Bridge"
46 static int acpi_pci_root_add(struct acpi_device *device);
47 static int acpi_pci_root_remove(struct acpi_device *device, int type);
48 static int acpi_pci_root_start(struct acpi_device *device);
49
50 static const struct acpi_device_id root_device_ids[] = {
51         {"PNP0A03", 0},
52         {"", 0},
53 };
54 MODULE_DEVICE_TABLE(acpi, root_device_ids);
55
56 static struct acpi_driver acpi_pci_root_driver = {
57         .name = "pci_root",
58         .class = ACPI_PCI_ROOT_CLASS,
59         .ids = root_device_ids,
60         .ops = {
61                 .add = acpi_pci_root_add,
62                 .remove = acpi_pci_root_remove,
63                 .start = acpi_pci_root_start,
64                 },
65 };
66
67 static LIST_HEAD(acpi_pci_roots);
68
69 static struct acpi_pci_driver *sub_driver;
70 static DEFINE_MUTEX(osc_lock);
71
72 int acpi_pci_register_driver(struct acpi_pci_driver *driver)
73 {
74         int n = 0;
75         struct acpi_pci_root *root;
76
77         struct acpi_pci_driver **pptr = &sub_driver;
78         while (*pptr)
79                 pptr = &(*pptr)->next;
80         *pptr = driver;
81
82         if (!driver->add)
83                 return 0;
84
85         list_for_each_entry(root, &acpi_pci_roots, node) {
86                 driver->add(root->device->handle);
87                 n++;
88         }
89
90         return n;
91 }
92
93 EXPORT_SYMBOL(acpi_pci_register_driver);
94
95 void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
96 {
97         struct acpi_pci_root *root;
98
99         struct acpi_pci_driver **pptr = &sub_driver;
100         while (*pptr) {
101                 if (*pptr == driver)
102                         break;
103                 pptr = &(*pptr)->next;
104         }
105         BUG_ON(!*pptr);
106         *pptr = (*pptr)->next;
107
108         if (!driver->remove)
109                 return;
110
111         list_for_each_entry(root, &acpi_pci_roots, node)
112                 driver->remove(root->device->handle);
113 }
114
115 EXPORT_SYMBOL(acpi_pci_unregister_driver);
116
117 acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
118 {
119         struct acpi_pci_root *root;
120         
121         list_for_each_entry(root, &acpi_pci_roots, node)
122                 if ((root->segment == (u16) seg) && (root->bus_nr == (u16) bus))
123                         return root->device->handle;
124         return NULL;            
125 }
126
127 EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle);
128
129 /**
130  * acpi_is_root_bridge - determine whether an ACPI CA node is a PCI root bridge
131  * @handle - the ACPI CA node in question.
132  *
133  * Note: we could make this API take a struct acpi_device * instead, but
134  * for now, it's more convenient to operate on an acpi_handle.
135  */
136 int acpi_is_root_bridge(acpi_handle handle)
137 {
138         int ret;
139         struct acpi_device *device;
140
141         ret = acpi_bus_get_device(handle, &device);
142         if (ret)
143                 return 0;
144
145         ret = acpi_match_device_ids(device, root_device_ids);
146         if (ret)
147                 return 0;
148         else
149                 return 1;
150 }
151 EXPORT_SYMBOL_GPL(acpi_is_root_bridge);
152
153 static acpi_status
154 get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
155 {
156         int *busnr = data;
157         struct acpi_resource_address64 address;
158
159         if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
160             resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
161             resource->type != ACPI_RESOURCE_TYPE_ADDRESS64)
162                 return AE_OK;
163
164         acpi_resource_to_address64(resource, &address);
165         if ((address.address_length > 0) &&
166             (address.resource_type == ACPI_BUS_NUMBER_RANGE))
167                 *busnr = address.minimum;
168
169         return AE_OK;
170 }
171
172 static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
173                                              unsigned long long *bus)
174 {
175         acpi_status status;
176         int busnum;
177
178         busnum = -1;
179         status =
180             acpi_walk_resources(handle, METHOD_NAME__CRS,
181                                 get_root_bridge_busnr_callback, &busnum);
182         if (ACPI_FAILURE(status))
183                 return status;
184         /* Check if we really get a bus number from _CRS */
185         if (busnum == -1)
186                 return AE_ERROR;
187         *bus = busnum;
188         return AE_OK;
189 }
190
191 static void acpi_pci_bridge_scan(struct acpi_device *device)
192 {
193         int status;
194         struct acpi_device *child = NULL;
195
196         if (device->flags.bus_address)
197                 if (device->parent && device->parent->ops.bind) {
198                         status = device->parent->ops.bind(device);
199                         if (!status) {
200                                 list_for_each_entry(child, &device->children, node)
201                                         acpi_pci_bridge_scan(child);
202                         }
203                 }
204 }
205
206 static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766";
207
208 static acpi_status acpi_pci_run_osc(acpi_handle handle,
209                                     const u32 *capbuf, u32 *retval)
210 {
211         struct acpi_osc_context context = {
212                 .uuid_str = pci_osc_uuid_str,
213                 .rev = 1,
214                 .cap.length = 12,
215                 .cap.pointer = (void *)capbuf,
216         };
217         acpi_status status;
218
219         status = acpi_run_osc(handle, &context);
220         if (ACPI_SUCCESS(status)) {
221                 *retval = *((u32 *)(context.ret.pointer + 8));
222                 kfree(context.ret.pointer);
223         }
224         return status;
225 }
226
227 static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root, u32 flags)
228 {
229         acpi_status status;
230         u32 support_set, result, capbuf[3];
231
232         /* do _OSC query for all possible controls */
233         support_set = root->osc_support_set | (flags & OSC_PCI_SUPPORT_MASKS);
234         capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
235         capbuf[OSC_SUPPORT_TYPE] = support_set;
236         capbuf[OSC_CONTROL_TYPE] = OSC_PCI_CONTROL_MASKS;
237
238         status = acpi_pci_run_osc(root->device->handle, capbuf, &result);
239         if (ACPI_SUCCESS(status)) {
240                 root->osc_support_set = support_set;
241                 root->osc_control_qry = result;
242                 root->osc_queried = 1;
243         }
244         return status;
245 }
246
247 static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags)
248 {
249         acpi_status status;
250         acpi_handle tmp;
251
252         status = acpi_get_handle(root->device->handle, "_OSC", &tmp);
253         if (ACPI_FAILURE(status))
254                 return status;
255         mutex_lock(&osc_lock);
256         status = acpi_pci_query_osc(root, flags);
257         mutex_unlock(&osc_lock);
258         return status;
259 }
260
261 struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle)
262 {
263         struct acpi_pci_root *root;
264
265         list_for_each_entry(root, &acpi_pci_roots, node) {
266                 if (root->device->handle == handle)
267                         return root;
268         }
269         return NULL;
270 }
271 EXPORT_SYMBOL_GPL(acpi_pci_find_root);
272
273 struct acpi_handle_node {
274         struct list_head node;
275         acpi_handle handle;
276 };
277
278 /**
279  * acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev
280  * @handle: the handle in question
281  *
282  * Given an ACPI CA handle, the desired PCI device is located in the
283  * list of PCI devices.
284  *
285  * If the device is found, its reference count is increased and this
286  * function returns a pointer to its data structure.  The caller must
287  * decrement the reference count by calling pci_dev_put().
288  * If no device is found, %NULL is returned.
289  */
290 struct pci_dev *acpi_get_pci_dev(acpi_handle handle)
291 {
292         int dev, fn;
293         unsigned long long adr;
294         acpi_status status;
295         acpi_handle phandle;
296         struct pci_bus *pbus;
297         struct pci_dev *pdev = NULL;
298         struct acpi_handle_node *node, *tmp;
299         struct acpi_pci_root *root;
300         LIST_HEAD(device_list);
301
302         /*
303          * Walk up the ACPI CA namespace until we reach a PCI root bridge.
304          */
305         phandle = handle;
306         while (!acpi_is_root_bridge(phandle)) {
307                 node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL);
308                 if (!node)
309                         goto out;
310
311                 INIT_LIST_HEAD(&node->node);
312                 node->handle = phandle;
313                 list_add(&node->node, &device_list);
314
315                 status = acpi_get_parent(phandle, &phandle);
316                 if (ACPI_FAILURE(status))
317                         goto out;
318         }
319
320         root = acpi_pci_find_root(phandle);
321         if (!root)
322                 goto out;
323
324         pbus = root->bus;
325
326         /*
327          * Now, walk back down the PCI device tree until we return to our
328          * original handle. Assumes that everything between the PCI root
329          * bridge and the device we're looking for must be a P2P bridge.
330          */
331         list_for_each_entry(node, &device_list, node) {
332                 acpi_handle hnd = node->handle;
333                 status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr);
334                 if (ACPI_FAILURE(status))
335                         goto out;
336                 dev = (adr >> 16) & 0xffff;
337                 fn  = adr & 0xffff;
338
339                 pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn));
340                 if (!pdev || hnd == handle)
341                         break;
342
343                 pbus = pdev->subordinate;
344                 pci_dev_put(pdev);
345
346                 /*
347                  * This function may be called for a non-PCI device that has a
348                  * PCI parent (eg. a disk under a PCI SATA controller).  In that
349                  * case pdev->subordinate will be NULL for the parent.
350                  */
351                 if (!pbus) {
352                         dev_dbg(&pdev->dev, "Not a PCI-to-PCI bridge\n");
353                         pdev = NULL;
354                         break;
355                 }
356         }
357 out:
358         list_for_each_entry_safe(node, tmp, &device_list, node)
359                 kfree(node);
360
361         return pdev;
362 }
363 EXPORT_SYMBOL_GPL(acpi_get_pci_dev);
364
365 /**
366  * acpi_pci_osc_control_set - commit requested control to Firmware
367  * @handle: acpi_handle for the target ACPI object
368  * @flags: driver's requested control bits
369  *
370  * Attempt to take control from Firmware on requested control bits.
371  **/
372 acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 flags)
373 {
374         acpi_status status;
375         u32 control_req, result, capbuf[3];
376         acpi_handle tmp;
377         struct acpi_pci_root *root;
378
379         status = acpi_get_handle(handle, "_OSC", &tmp);
380         if (ACPI_FAILURE(status))
381                 return status;
382
383         control_req = (flags & OSC_PCI_CONTROL_MASKS);
384         if (!control_req)
385                 return AE_TYPE;
386
387         root = acpi_pci_find_root(handle);
388         if (!root)
389                 return AE_NOT_EXIST;
390
391         mutex_lock(&osc_lock);
392         /* No need to evaluate _OSC if the control was already granted. */
393         if ((root->osc_control_set & control_req) == control_req)
394                 goto out;
395
396         /* Need to query controls first before requesting them */
397         if (!root->osc_queried) {
398                 status = acpi_pci_query_osc(root, root->osc_support_set);
399                 if (ACPI_FAILURE(status))
400                         goto out;
401         }
402         if ((root->osc_control_qry & control_req) != control_req) {
403                 printk(KERN_DEBUG
404                        "Firmware did not grant requested _OSC control\n");
405                 status = AE_SUPPORT;
406                 goto out;
407         }
408
409         capbuf[OSC_QUERY_TYPE] = 0;
410         capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;
411         capbuf[OSC_CONTROL_TYPE] = root->osc_control_set | control_req;
412         status = acpi_pci_run_osc(handle, capbuf, &result);
413         if (ACPI_SUCCESS(status))
414                 root->osc_control_set = result;
415 out:
416         mutex_unlock(&osc_lock);
417         return status;
418 }
419 EXPORT_SYMBOL(acpi_pci_osc_control_set);
420
421 static int __devinit acpi_pci_root_add(struct acpi_device *device)
422 {
423         unsigned long long segment, bus;
424         acpi_status status;
425         int result;
426         struct acpi_pci_root *root;
427         acpi_handle handle;
428         struct acpi_device *child;
429         u32 flags, base_flags;
430
431         segment = 0;
432         status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
433                                        &segment);
434         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
435                 printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
436                 return -ENODEV;
437         }
438
439         /* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
440         bus = 0;
441         status = try_get_root_bridge_busnr(device->handle, &bus);
442         if (ACPI_FAILURE(status)) {
443                 status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,                                               NULL, &bus);
444                 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
445                         printk(KERN_ERR PREFIX
446                              "no bus number in _CRS and can't evaluate _BBN\n");
447                         return -ENODEV;
448                 }
449         }
450
451         root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
452         if (!root)
453                 return -ENOMEM;
454
455         INIT_LIST_HEAD(&root->node);
456         root->device = device;
457         root->segment = segment & 0xFFFF;
458         root->bus_nr = bus & 0xFF;
459         strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
460         strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
461         device->driver_data = root;
462
463         /*
464          * All supported architectures that use ACPI have support for
465          * PCI domains, so we indicate this in _OSC support capabilities.
466          */
467         flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
468         acpi_pci_osc_support(root, flags);
469
470         /*
471          * TBD: Need PCI interface for enumeration/configuration of roots.
472          */
473
474         /* TBD: Locking */
475         list_add_tail(&root->node, &acpi_pci_roots);
476
477         printk(KERN_INFO PREFIX "%s [%s] (%04x:%02x)\n",
478                acpi_device_name(device), acpi_device_bid(device),
479                root->segment, root->bus_nr);
480
481         /*
482          * Scan the Root Bridge
483          * --------------------
484          * Must do this prior to any attempt to bind the root device, as the
485          * PCI namespace does not get created until this call is made (and 
486          * thus the root bridge's pci_dev does not exist).
487          */
488         root->bus = pci_acpi_scan_root(device, segment, bus);
489         if (!root->bus) {
490                 printk(KERN_ERR PREFIX
491                             "Bus %04x:%02x not present in PCI namespace\n",
492                             root->segment, root->bus_nr);
493                 result = -ENODEV;
494                 goto end;
495         }
496
497         /*
498          * Attach ACPI-PCI Context
499          * -----------------------
500          * Thus binding the ACPI and PCI devices.
501          */
502         result = acpi_pci_bind_root(device);
503         if (result)
504                 goto end;
505
506         /*
507          * PCI Routing Table
508          * -----------------
509          * Evaluate and parse _PRT, if exists.
510          */
511         status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
512         if (ACPI_SUCCESS(status))
513                 result = acpi_pci_irq_add_prt(device->handle, root->bus);
514
515         /*
516          * Scan and bind all _ADR-Based Devices
517          */
518         list_for_each_entry(child, &device->children, node)
519                 acpi_pci_bridge_scan(child);
520
521         /* Indicate support for various _OSC capabilities. */
522         if (pci_ext_cfg_avail(root->bus->self))
523                 flags |= OSC_EXT_PCI_CONFIG_SUPPORT;
524         if (pcie_aspm_enabled())
525                 flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |
526                         OSC_CLOCK_PWR_CAPABILITY_SUPPORT;
527         if (pci_msi_enabled())
528                 flags |= OSC_MSI_SUPPORT;
529         if (flags != base_flags)
530                 acpi_pci_osc_support(root, flags);
531
532         pci_acpi_add_bus_pm_notifier(device, root->bus);
533         if (device->wakeup.flags.run_wake)
534                 device_set_run_wake(root->bus->bridge, true);
535
536         return 0;
537
538 end:
539         if (!list_empty(&root->node))
540                 list_del(&root->node);
541         kfree(root);
542         return result;
543 }
544
545 static int acpi_pci_root_start(struct acpi_device *device)
546 {
547         struct acpi_pci_root *root = acpi_driver_data(device);
548
549         pci_bus_add_devices(root->bus);
550         return 0;
551 }
552
553 static int acpi_pci_root_remove(struct acpi_device *device, int type)
554 {
555         struct acpi_pci_root *root = acpi_driver_data(device);
556
557         device_set_run_wake(root->bus->bridge, false);
558         pci_acpi_remove_bus_pm_notifier(device);
559
560         kfree(root);
561         return 0;
562 }
563
564 static int __init acpi_pci_root_init(void)
565 {
566         if (acpi_pci_disabled)
567                 return 0;
568
569         if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
570                 return -ENODEV;
571
572         return 0;
573 }
574
575 subsys_initcall(acpi_pci_root_init);