ACPI: pci_root: save downstream bus range
[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) &&
123                     (root->secondary.start == (u16) bus))
124                         return root->device->handle;
125         return NULL;            
126 }
127
128 EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle);
129
130 /**
131  * acpi_is_root_bridge - determine whether an ACPI CA node is a PCI root bridge
132  * @handle - the ACPI CA node in question.
133  *
134  * Note: we could make this API take a struct acpi_device * instead, but
135  * for now, it's more convenient to operate on an acpi_handle.
136  */
137 int acpi_is_root_bridge(acpi_handle handle)
138 {
139         int ret;
140         struct acpi_device *device;
141
142         ret = acpi_bus_get_device(handle, &device);
143         if (ret)
144                 return 0;
145
146         ret = acpi_match_device_ids(device, root_device_ids);
147         if (ret)
148                 return 0;
149         else
150                 return 1;
151 }
152 EXPORT_SYMBOL_GPL(acpi_is_root_bridge);
153
154 static acpi_status
155 get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
156 {
157         struct resource *res = data;
158         struct acpi_resource_address64 address;
159
160         if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
161             resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
162             resource->type != ACPI_RESOURCE_TYPE_ADDRESS64)
163                 return AE_OK;
164
165         acpi_resource_to_address64(resource, &address);
166         if ((address.address_length > 0) &&
167             (address.resource_type == ACPI_BUS_NUMBER_RANGE)) {
168                 res->start = address.minimum;
169                 res->end = address.minimum + address.address_length - 1;
170         }
171
172         return AE_OK;
173 }
174
175 static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
176                                              struct resource *res)
177 {
178         acpi_status status;
179
180         res->start = -1;
181         status =
182             acpi_walk_resources(handle, METHOD_NAME__CRS,
183                                 get_root_bridge_busnr_callback, res);
184         if (ACPI_FAILURE(status))
185                 return status;
186         if (res->start == -1)
187                 return AE_ERROR;
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         root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
432         if (!root)
433                 return -ENOMEM;
434
435         segment = 0;
436         status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
437                                        &segment);
438         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
439                 printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
440                 result = -ENODEV;
441                 goto end;
442         }
443
444         /* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
445         root->secondary.flags = IORESOURCE_BUS;
446         status = try_get_root_bridge_busnr(device->handle, &root->secondary);
447         if (ACPI_FAILURE(status)) {
448                 /*
449                  * We need both the start and end of the downstream bus range
450                  * to interpret _CBA (MMCONFIG base address), so it really is
451                  * supposed to be in _CRS.  If we don't find it there, all we
452                  * can do is assume [_BBN-0xFF] or [0-0xFF].
453                  */
454                 root->secondary.end = 0xFF;
455                 printk(KERN_WARNING FW_BUG PREFIX
456                        "no secondary bus range in _CRS\n");
457                 status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,                                               NULL, &bus);
458                 if (ACPI_SUCCESS(status))
459                         root->secondary.start = bus;
460                 else if (status == AE_NOT_FOUND)
461                         root->secondary.start = 0;
462                 else {
463                         printk(KERN_ERR PREFIX "can't evaluate _BBN\n");
464                         result = -ENODEV;
465                         goto end;
466                 }
467         }
468
469         INIT_LIST_HEAD(&root->node);
470         root->device = device;
471         root->segment = segment & 0xFFFF;
472         strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
473         strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
474         device->driver_data = root;
475
476         /*
477          * All supported architectures that use ACPI have support for
478          * PCI domains, so we indicate this in _OSC support capabilities.
479          */
480         flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
481         acpi_pci_osc_support(root, flags);
482
483         /*
484          * TBD: Need PCI interface for enumeration/configuration of roots.
485          */
486
487         /* TBD: Locking */
488         list_add_tail(&root->node, &acpi_pci_roots);
489
490         printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
491                acpi_device_name(device), acpi_device_bid(device),
492                root->segment, &root->secondary);
493
494         /*
495          * Scan the Root Bridge
496          * --------------------
497          * Must do this prior to any attempt to bind the root device, as the
498          * PCI namespace does not get created until this call is made (and 
499          * thus the root bridge's pci_dev does not exist).
500          */
501         root->bus = pci_acpi_scan_root(device, segment, root->secondary.start);
502         if (!root->bus) {
503                 printk(KERN_ERR PREFIX
504                             "Bus %04x:%02x not present in PCI namespace\n",
505                             root->segment, (unsigned int)root->secondary.start);
506                 result = -ENODEV;
507                 goto end;
508         }
509
510         /*
511          * Attach ACPI-PCI Context
512          * -----------------------
513          * Thus binding the ACPI and PCI devices.
514          */
515         result = acpi_pci_bind_root(device);
516         if (result)
517                 goto end;
518
519         /*
520          * PCI Routing Table
521          * -----------------
522          * Evaluate and parse _PRT, if exists.
523          */
524         status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
525         if (ACPI_SUCCESS(status))
526                 result = acpi_pci_irq_add_prt(device->handle, root->bus);
527
528         /*
529          * Scan and bind all _ADR-Based Devices
530          */
531         list_for_each_entry(child, &device->children, node)
532                 acpi_pci_bridge_scan(child);
533
534         /* Indicate support for various _OSC capabilities. */
535         if (pci_ext_cfg_avail(root->bus->self))
536                 flags |= OSC_EXT_PCI_CONFIG_SUPPORT;
537         if (pcie_aspm_enabled())
538                 flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |
539                         OSC_CLOCK_PWR_CAPABILITY_SUPPORT;
540         if (pci_msi_enabled())
541                 flags |= OSC_MSI_SUPPORT;
542         if (flags != base_flags)
543                 acpi_pci_osc_support(root, flags);
544
545         pci_acpi_add_bus_pm_notifier(device, root->bus);
546         if (device->wakeup.flags.run_wake)
547                 device_set_run_wake(root->bus->bridge, true);
548
549         return 0;
550
551 end:
552         if (!list_empty(&root->node))
553                 list_del(&root->node);
554         kfree(root);
555         return result;
556 }
557
558 static int acpi_pci_root_start(struct acpi_device *device)
559 {
560         struct acpi_pci_root *root = acpi_driver_data(device);
561
562         pci_bus_add_devices(root->bus);
563         return 0;
564 }
565
566 static int acpi_pci_root_remove(struct acpi_device *device, int type)
567 {
568         struct acpi_pci_root *root = acpi_driver_data(device);
569
570         device_set_run_wake(root->bus->bridge, false);
571         pci_acpi_remove_bus_pm_notifier(device);
572
573         kfree(root);
574         return 0;
575 }
576
577 static int __init acpi_pci_root_init(void)
578 {
579         if (acpi_pci_disabled)
580                 return 0;
581
582         pci_acpi_crs_quirks();
583         if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
584                 return -ENODEV;
585
586         return 0;
587 }
588
589 subsys_initcall(acpi_pci_root_init);