← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/acpi/pci_root.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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/spinlock.h>
 
31
#include <linux/pm.h>
 
32
#include <linux/pm_runtime.h>
 
33
#include <linux/pci.h>
 
34
#include <linux/pci-acpi.h>
 
35
#include <linux/pci-aspm.h>
 
36
#include <linux/acpi.h>
 
37
#include <linux/slab.h>
 
38
#include <acpi/acpi_bus.h>
 
39
#include <acpi/acpi_drivers.h>
 
40
#include <acpi/apei.h>
 
41
 
 
42
#define PREFIX "ACPI: "
 
43
 
 
44
#define _COMPONENT              ACPI_PCI_COMPONENT
 
45
ACPI_MODULE_NAME("pci_root");
 
46
#define ACPI_PCI_ROOT_CLASS             "pci_bridge"
 
47
#define ACPI_PCI_ROOT_DEVICE_NAME       "PCI Root Bridge"
 
48
static int acpi_pci_root_add(struct acpi_device *device);
 
49
static int acpi_pci_root_remove(struct acpi_device *device, int type);
 
50
static int acpi_pci_root_start(struct acpi_device *device);
 
51
 
 
52
#define ACPI_PCIE_REQ_SUPPORT (OSC_EXT_PCI_CONFIG_SUPPORT \
 
53
                                | OSC_ACTIVE_STATE_PWR_SUPPORT \
 
54
                                | OSC_CLOCK_PWR_CAPABILITY_SUPPORT \
 
55
                                | OSC_MSI_SUPPORT)
 
56
 
 
57
static const struct acpi_device_id root_device_ids[] = {
 
58
        {"PNP0A03", 0},
 
59
        {"", 0},
 
60
};
 
61
MODULE_DEVICE_TABLE(acpi, root_device_ids);
 
62
 
 
63
static struct acpi_driver acpi_pci_root_driver = {
 
64
        .name = "pci_root",
 
65
        .class = ACPI_PCI_ROOT_CLASS,
 
66
        .ids = root_device_ids,
 
67
        .ops = {
 
68
                .add = acpi_pci_root_add,
 
69
                .remove = acpi_pci_root_remove,
 
70
                .start = acpi_pci_root_start,
 
71
                },
 
72
};
 
73
 
 
74
static LIST_HEAD(acpi_pci_roots);
 
75
 
 
76
static struct acpi_pci_driver *sub_driver;
 
77
static DEFINE_MUTEX(osc_lock);
 
78
 
 
79
int acpi_pci_register_driver(struct acpi_pci_driver *driver)
 
80
{
 
81
        int n = 0;
 
82
        struct acpi_pci_root *root;
 
83
 
 
84
        struct acpi_pci_driver **pptr = &sub_driver;
 
85
        while (*pptr)
 
86
                pptr = &(*pptr)->next;
 
87
        *pptr = driver;
 
88
 
 
89
        if (!driver->add)
 
90
                return 0;
 
91
 
 
92
        list_for_each_entry(root, &acpi_pci_roots, node) {
 
93
                driver->add(root->device->handle);
 
94
                n++;
 
95
        }
 
96
 
 
97
        return n;
 
98
}
 
99
 
 
100
EXPORT_SYMBOL(acpi_pci_register_driver);
 
101
 
 
102
void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
 
103
{
 
104
        struct acpi_pci_root *root;
 
105
 
 
106
        struct acpi_pci_driver **pptr = &sub_driver;
 
107
        while (*pptr) {
 
108
                if (*pptr == driver)
 
109
                        break;
 
110
                pptr = &(*pptr)->next;
 
111
        }
 
112
        BUG_ON(!*pptr);
 
113
        *pptr = (*pptr)->next;
 
114
 
 
115
        if (!driver->remove)
 
116
                return;
 
117
 
 
118
        list_for_each_entry(root, &acpi_pci_roots, node)
 
119
                driver->remove(root->device->handle);
 
120
}
 
121
 
 
122
EXPORT_SYMBOL(acpi_pci_unregister_driver);
 
123
 
 
124
acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
 
125
{
 
126
        struct acpi_pci_root *root;
 
127
        
 
128
        list_for_each_entry(root, &acpi_pci_roots, node)
 
129
                if ((root->segment == (u16) seg) &&
 
130
                    (root->secondary.start == (u16) bus))
 
131
                        return root->device->handle;
 
132
        return NULL;            
 
133
}
 
134
 
 
135
EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle);
 
136
 
 
137
/**
 
138
 * acpi_is_root_bridge - determine whether an ACPI CA node is a PCI root bridge
 
139
 * @handle - the ACPI CA node in question.
 
140
 *
 
141
 * Note: we could make this API take a struct acpi_device * instead, but
 
142
 * for now, it's more convenient to operate on an acpi_handle.
 
143
 */
 
144
int acpi_is_root_bridge(acpi_handle handle)
 
145
{
 
146
        int ret;
 
147
        struct acpi_device *device;
 
148
 
 
149
        ret = acpi_bus_get_device(handle, &device);
 
150
        if (ret)
 
151
                return 0;
 
152
 
 
153
        ret = acpi_match_device_ids(device, root_device_ids);
 
154
        if (ret)
 
155
                return 0;
 
156
        else
 
157
                return 1;
 
158
}
 
159
EXPORT_SYMBOL_GPL(acpi_is_root_bridge);
 
160
 
 
161
static acpi_status
 
162
get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
 
163
{
 
164
        struct resource *res = data;
 
165
        struct acpi_resource_address64 address;
 
166
 
 
167
        if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
 
168
            resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
 
169
            resource->type != ACPI_RESOURCE_TYPE_ADDRESS64)
 
170
                return AE_OK;
 
171
 
 
172
        acpi_resource_to_address64(resource, &address);
 
173
        if ((address.address_length > 0) &&
 
174
            (address.resource_type == ACPI_BUS_NUMBER_RANGE)) {
 
175
                res->start = address.minimum;
 
176
                res->end = address.minimum + address.address_length - 1;
 
177
        }
 
178
 
 
179
        return AE_OK;
 
180
}
 
181
 
 
182
static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
 
183
                                             struct resource *res)
 
184
{
 
185
        acpi_status status;
 
186
 
 
187
        res->start = -1;
 
188
        status =
 
189
            acpi_walk_resources(handle, METHOD_NAME__CRS,
 
190
                                get_root_bridge_busnr_callback, res);
 
191
        if (ACPI_FAILURE(status))
 
192
                return status;
 
193
        if (res->start == -1)
 
194
                return AE_ERROR;
 
195
        return AE_OK;
 
196
}
 
197
 
 
198
static void acpi_pci_bridge_scan(struct acpi_device *device)
 
199
{
 
200
        int status;
 
201
        struct acpi_device *child = NULL;
 
202
 
 
203
        if (device->flags.bus_address)
 
204
                if (device->parent && device->parent->ops.bind) {
 
205
                        status = device->parent->ops.bind(device);
 
206
                        if (!status) {
 
207
                                list_for_each_entry(child, &device->children, node)
 
208
                                        acpi_pci_bridge_scan(child);
 
209
                        }
 
210
                }
 
211
}
 
212
 
 
213
static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766";
 
214
 
 
215
static acpi_status acpi_pci_run_osc(acpi_handle handle,
 
216
                                    const u32 *capbuf, u32 *retval)
 
217
{
 
218
        struct acpi_osc_context context = {
 
219
                .uuid_str = pci_osc_uuid_str,
 
220
                .rev = 1,
 
221
                .cap.length = 12,
 
222
                .cap.pointer = (void *)capbuf,
 
223
        };
 
224
        acpi_status status;
 
225
 
 
226
        status = acpi_run_osc(handle, &context);
 
227
        if (ACPI_SUCCESS(status)) {
 
228
                *retval = *((u32 *)(context.ret.pointer + 8));
 
229
                kfree(context.ret.pointer);
 
230
        }
 
231
        return status;
 
232
}
 
233
 
 
234
static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root,
 
235
                                        u32 support,
 
236
                                        u32 *control)
 
237
{
 
238
        acpi_status status;
 
239
        u32 result, capbuf[3];
 
240
 
 
241
        support &= OSC_PCI_SUPPORT_MASKS;
 
242
        support |= root->osc_support_set;
 
243
 
 
244
        capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
 
245
        capbuf[OSC_SUPPORT_TYPE] = support;
 
246
        if (control) {
 
247
                *control &= OSC_PCI_CONTROL_MASKS;
 
248
                capbuf[OSC_CONTROL_TYPE] = *control | root->osc_control_set;
 
249
        } else {
 
250
                /* Run _OSC query for all possible controls. */
 
251
                capbuf[OSC_CONTROL_TYPE] = OSC_PCI_CONTROL_MASKS;
 
252
        }
 
253
 
 
254
        status = acpi_pci_run_osc(root->device->handle, capbuf, &result);
 
255
        if (ACPI_SUCCESS(status)) {
 
256
                root->osc_support_set = support;
 
257
                if (control)
 
258
                        *control = result;
 
259
        }
 
260
        return status;
 
261
}
 
262
 
 
263
static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags)
 
264
{
 
265
        acpi_status status;
 
266
        acpi_handle tmp;
 
267
 
 
268
        status = acpi_get_handle(root->device->handle, "_OSC", &tmp);
 
269
        if (ACPI_FAILURE(status))
 
270
                return status;
 
271
        mutex_lock(&osc_lock);
 
272
        status = acpi_pci_query_osc(root, flags, NULL);
 
273
        mutex_unlock(&osc_lock);
 
274
        return status;
 
275
}
 
276
 
 
277
struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle)
 
278
{
 
279
        struct acpi_pci_root *root;
 
280
 
 
281
        list_for_each_entry(root, &acpi_pci_roots, node) {
 
282
                if (root->device->handle == handle)
 
283
                        return root;
 
284
        }
 
285
        return NULL;
 
286
}
 
287
EXPORT_SYMBOL_GPL(acpi_pci_find_root);
 
288
 
 
289
struct acpi_handle_node {
 
290
        struct list_head node;
 
291
        acpi_handle handle;
 
292
};
 
293
 
 
294
/**
 
295
 * acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev
 
296
 * @handle: the handle in question
 
297
 *
 
298
 * Given an ACPI CA handle, the desired PCI device is located in the
 
299
 * list of PCI devices.
 
300
 *
 
301
 * If the device is found, its reference count is increased and this
 
302
 * function returns a pointer to its data structure.  The caller must
 
303
 * decrement the reference count by calling pci_dev_put().
 
304
 * If no device is found, %NULL is returned.
 
305
 */
 
306
struct pci_dev *acpi_get_pci_dev(acpi_handle handle)
 
307
{
 
308
        int dev, fn;
 
309
        unsigned long long adr;
 
310
        acpi_status status;
 
311
        acpi_handle phandle;
 
312
        struct pci_bus *pbus;
 
313
        struct pci_dev *pdev = NULL;
 
314
        struct acpi_handle_node *node, *tmp;
 
315
        struct acpi_pci_root *root;
 
316
        LIST_HEAD(device_list);
 
317
 
 
318
        /*
 
319
         * Walk up the ACPI CA namespace until we reach a PCI root bridge.
 
320
         */
 
321
        phandle = handle;
 
322
        while (!acpi_is_root_bridge(phandle)) {
 
323
                node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL);
 
324
                if (!node)
 
325
                        goto out;
 
326
 
 
327
                INIT_LIST_HEAD(&node->node);
 
328
                node->handle = phandle;
 
329
                list_add(&node->node, &device_list);
 
330
 
 
331
                status = acpi_get_parent(phandle, &phandle);
 
332
                if (ACPI_FAILURE(status))
 
333
                        goto out;
 
334
        }
 
335
 
 
336
        root = acpi_pci_find_root(phandle);
 
337
        if (!root)
 
338
                goto out;
 
339
 
 
340
        pbus = root->bus;
 
341
 
 
342
        /*
 
343
         * Now, walk back down the PCI device tree until we return to our
 
344
         * original handle. Assumes that everything between the PCI root
 
345
         * bridge and the device we're looking for must be a P2P bridge.
 
346
         */
 
347
        list_for_each_entry(node, &device_list, node) {
 
348
                acpi_handle hnd = node->handle;
 
349
                status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr);
 
350
                if (ACPI_FAILURE(status))
 
351
                        goto out;
 
352
                dev = (adr >> 16) & 0xffff;
 
353
                fn  = adr & 0xffff;
 
354
 
 
355
                pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn));
 
356
                if (!pdev || hnd == handle)
 
357
                        break;
 
358
 
 
359
                pbus = pdev->subordinate;
 
360
                pci_dev_put(pdev);
 
361
 
 
362
                /*
 
363
                 * This function may be called for a non-PCI device that has a
 
364
                 * PCI parent (eg. a disk under a PCI SATA controller).  In that
 
365
                 * case pdev->subordinate will be NULL for the parent.
 
366
                 */
 
367
                if (!pbus) {
 
368
                        dev_dbg(&pdev->dev, "Not a PCI-to-PCI bridge\n");
 
369
                        pdev = NULL;
 
370
                        break;
 
371
                }
 
372
        }
 
373
out:
 
374
        list_for_each_entry_safe(node, tmp, &device_list, node)
 
375
                kfree(node);
 
376
 
 
377
        return pdev;
 
378
}
 
379
EXPORT_SYMBOL_GPL(acpi_get_pci_dev);
 
380
 
 
381
/**
 
382
 * acpi_pci_osc_control_set - Request control of PCI root _OSC features.
 
383
 * @handle: ACPI handle of a PCI root bridge (or PCIe Root Complex).
 
384
 * @mask: Mask of _OSC bits to request control of, place to store control mask.
 
385
 * @req: Mask of _OSC bits the control of is essential to the caller.
 
386
 *
 
387
 * Run _OSC query for @mask and if that is successful, compare the returned
 
388
 * mask of control bits with @req.  If all of the @req bits are set in the
 
389
 * returned mask, run _OSC request for it.
 
390
 *
 
391
 * The variable at the @mask address may be modified regardless of whether or
 
392
 * not the function returns success.  On success it will contain the mask of
 
393
 * _OSC bits the BIOS has granted control of, but its contents are meaningless
 
394
 * on failure.
 
395
 **/
 
396
acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req)
 
397
{
 
398
        struct acpi_pci_root *root;
 
399
        acpi_status status;
 
400
        u32 ctrl, capbuf[3];
 
401
        acpi_handle tmp;
 
402
 
 
403
        if (!mask)
 
404
                return AE_BAD_PARAMETER;
 
405
 
 
406
        ctrl = *mask & OSC_PCI_CONTROL_MASKS;
 
407
        if ((ctrl & req) != req)
 
408
                return AE_TYPE;
 
409
 
 
410
        root = acpi_pci_find_root(handle);
 
411
        if (!root)
 
412
                return AE_NOT_EXIST;
 
413
 
 
414
        status = acpi_get_handle(handle, "_OSC", &tmp);
 
415
        if (ACPI_FAILURE(status))
 
416
                return status;
 
417
 
 
418
        mutex_lock(&osc_lock);
 
419
 
 
420
        *mask = ctrl | root->osc_control_set;
 
421
        /* No need to evaluate _OSC if the control was already granted. */
 
422
        if ((root->osc_control_set & ctrl) == ctrl)
 
423
                goto out;
 
424
 
 
425
        /* Need to check the available controls bits before requesting them. */
 
426
        while (*mask) {
 
427
                status = acpi_pci_query_osc(root, root->osc_support_set, mask);
 
428
                if (ACPI_FAILURE(status))
 
429
                        goto out;
 
430
                if (ctrl == *mask)
 
431
                        break;
 
432
                ctrl = *mask;
 
433
        }
 
434
 
 
435
        if ((ctrl & req) != req) {
 
436
                status = AE_SUPPORT;
 
437
                goto out;
 
438
        }
 
439
 
 
440
        capbuf[OSC_QUERY_TYPE] = 0;
 
441
        capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;
 
442
        capbuf[OSC_CONTROL_TYPE] = ctrl;
 
443
        status = acpi_pci_run_osc(handle, capbuf, mask);
 
444
        if (ACPI_SUCCESS(status))
 
445
                root->osc_control_set = *mask;
 
446
out:
 
447
        mutex_unlock(&osc_lock);
 
448
        return status;
 
449
}
 
450
EXPORT_SYMBOL(acpi_pci_osc_control_set);
 
451
 
 
452
static int __devinit acpi_pci_root_add(struct acpi_device *device)
 
453
{
 
454
        unsigned long long segment, bus;
 
455
        acpi_status status;
 
456
        int result;
 
457
        struct acpi_pci_root *root;
 
458
        acpi_handle handle;
 
459
        struct acpi_device *child;
 
460
        u32 flags, base_flags;
 
461
 
 
462
        root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
 
463
        if (!root)
 
464
                return -ENOMEM;
 
465
 
 
466
        segment = 0;
 
467
        status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
 
468
                                       &segment);
 
469
        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 
470
                printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
 
471
                result = -ENODEV;
 
472
                goto end;
 
473
        }
 
474
 
 
475
        /* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
 
476
        root->secondary.flags = IORESOURCE_BUS;
 
477
        status = try_get_root_bridge_busnr(device->handle, &root->secondary);
 
478
        if (ACPI_FAILURE(status)) {
 
479
                /*
 
480
                 * We need both the start and end of the downstream bus range
 
481
                 * to interpret _CBA (MMCONFIG base address), so it really is
 
482
                 * supposed to be in _CRS.  If we don't find it there, all we
 
483
                 * can do is assume [_BBN-0xFF] or [0-0xFF].
 
484
                 */
 
485
                root->secondary.end = 0xFF;
 
486
                printk(KERN_WARNING FW_BUG PREFIX
 
487
                       "no secondary bus range in _CRS\n");
 
488
                status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,
 
489
                                               NULL, &bus);
 
490
                if (ACPI_SUCCESS(status))
 
491
                        root->secondary.start = bus;
 
492
                else if (status == AE_NOT_FOUND)
 
493
                        root->secondary.start = 0;
 
494
                else {
 
495
                        printk(KERN_ERR PREFIX "can't evaluate _BBN\n");
 
496
                        result = -ENODEV;
 
497
                        goto end;
 
498
                }
 
499
        }
 
500
 
 
501
        INIT_LIST_HEAD(&root->node);
 
502
        root->device = device;
 
503
        root->segment = segment & 0xFFFF;
 
504
        strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
 
505
        strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
 
506
        device->driver_data = root;
 
507
 
 
508
        /*
 
509
         * All supported architectures that use ACPI have support for
 
510
         * PCI domains, so we indicate this in _OSC support capabilities.
 
511
         */
 
512
        flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
 
513
        acpi_pci_osc_support(root, flags);
 
514
 
 
515
        /*
 
516
         * TBD: Need PCI interface for enumeration/configuration of roots.
 
517
         */
 
518
 
 
519
        /* TBD: Locking */
 
520
        list_add_tail(&root->node, &acpi_pci_roots);
 
521
 
 
522
        printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
 
523
               acpi_device_name(device), acpi_device_bid(device),
 
524
               root->segment, &root->secondary);
 
525
 
 
526
        /*
 
527
         * Scan the Root Bridge
 
528
         * --------------------
 
529
         * Must do this prior to any attempt to bind the root device, as the
 
530
         * PCI namespace does not get created until this call is made (and 
 
531
         * thus the root bridge's pci_dev does not exist).
 
532
         */
 
533
        root->bus = pci_acpi_scan_root(root);
 
534
        if (!root->bus) {
 
535
                printk(KERN_ERR PREFIX
 
536
                            "Bus %04x:%02x not present in PCI namespace\n",
 
537
                            root->segment, (unsigned int)root->secondary.start);
 
538
                result = -ENODEV;
 
539
                goto end;
 
540
        }
 
541
 
 
542
        /*
 
543
         * Attach ACPI-PCI Context
 
544
         * -----------------------
 
545
         * Thus binding the ACPI and PCI devices.
 
546
         */
 
547
        result = acpi_pci_bind_root(device);
 
548
        if (result)
 
549
                goto end;
 
550
 
 
551
        /*
 
552
         * PCI Routing Table
 
553
         * -----------------
 
554
         * Evaluate and parse _PRT, if exists.
 
555
         */
 
556
        status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
 
557
        if (ACPI_SUCCESS(status))
 
558
                result = acpi_pci_irq_add_prt(device->handle, root->bus);
 
559
 
 
560
        /*
 
561
         * Scan and bind all _ADR-Based Devices
 
562
         */
 
563
        list_for_each_entry(child, &device->children, node)
 
564
                acpi_pci_bridge_scan(child);
 
565
 
 
566
        /* Indicate support for various _OSC capabilities. */
 
567
        if (pci_ext_cfg_avail(root->bus->self))
 
568
                flags |= OSC_EXT_PCI_CONFIG_SUPPORT;
 
569
        if (pcie_aspm_support_enabled())
 
570
                flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |
 
571
                        OSC_CLOCK_PWR_CAPABILITY_SUPPORT;
 
572
        if (pci_msi_enabled())
 
573
                flags |= OSC_MSI_SUPPORT;
 
574
        if (flags != base_flags)
 
575
                acpi_pci_osc_support(root, flags);
 
576
 
 
577
        if (!pcie_ports_disabled
 
578
            && (flags & ACPI_PCIE_REQ_SUPPORT) == ACPI_PCIE_REQ_SUPPORT) {
 
579
                flags = OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL
 
580
                        | OSC_PCI_EXPRESS_NATIVE_HP_CONTROL
 
581
                        | OSC_PCI_EXPRESS_PME_CONTROL;
 
582
 
 
583
                if (pci_aer_available()) {
 
584
                        if (aer_acpi_firmware_first())
 
585
                                dev_dbg(root->bus->bridge,
 
586
                                        "PCIe errors handled by BIOS.\n");
 
587
                        else
 
588
                                flags |= OSC_PCI_EXPRESS_AER_CONTROL;
 
589
                }
 
590
 
 
591
                dev_info(root->bus->bridge,
 
592
                        "Requesting ACPI _OSC control (0x%02x)\n", flags);
 
593
 
 
594
                status = acpi_pci_osc_control_set(device->handle, &flags,
 
595
                                        OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
 
596
                if (ACPI_SUCCESS(status)) {
 
597
                        dev_info(root->bus->bridge,
 
598
                                "ACPI _OSC control (0x%02x) granted\n", flags);
 
599
                } else {
 
600
                        dev_info(root->bus->bridge,
 
601
                                "ACPI _OSC request failed (%s), "
 
602
                                "returned control mask: 0x%02x\n",
 
603
                                acpi_format_exception(status), flags);
 
604
                        pr_info("ACPI _OSC control for PCIe not granted, "
 
605
                                "disabling ASPM\n");
 
606
                        pcie_no_aspm();
 
607
                }
 
608
        } else {
 
609
                dev_info(root->bus->bridge,
 
610
                         "Unable to request _OSC control "
 
611
                         "(_OSC support mask: 0x%02x)\n", flags);
 
612
        }
 
613
 
 
614
        pci_acpi_add_bus_pm_notifier(device, root->bus);
 
615
        if (device->wakeup.flags.run_wake)
 
616
                device_set_run_wake(root->bus->bridge, true);
 
617
 
 
618
        return 0;
 
619
 
 
620
end:
 
621
        if (!list_empty(&root->node))
 
622
                list_del(&root->node);
 
623
        kfree(root);
 
624
        return result;
 
625
}
 
626
 
 
627
static int acpi_pci_root_start(struct acpi_device *device)
 
628
{
 
629
        struct acpi_pci_root *root = acpi_driver_data(device);
 
630
 
 
631
        pci_bus_add_devices(root->bus);
 
632
        return 0;
 
633
}
 
634
 
 
635
static int acpi_pci_root_remove(struct acpi_device *device, int type)
 
636
{
 
637
        struct acpi_pci_root *root = acpi_driver_data(device);
 
638
 
 
639
        device_set_run_wake(root->bus->bridge, false);
 
640
        pci_acpi_remove_bus_pm_notifier(device);
 
641
 
 
642
        kfree(root);
 
643
        return 0;
 
644
}
 
645
 
 
646
static int __init acpi_pci_root_init(void)
 
647
{
 
648
        acpi_hest_init();
 
649
 
 
650
        if (acpi_pci_disabled)
 
651
                return 0;
 
652
 
 
653
        pci_acpi_crs_quirks();
 
654
        if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
 
655
                return -ENODEV;
 
656
 
 
657
        return 0;
 
658
}
 
659
 
 
660
subsys_initcall(acpi_pci_root_init);