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