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