xref: /linux/drivers/pci/hotplug/acpi_pcihp.c (revision bfd5bb6f90af092aa345b15cd78143956a13c2a8)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Common ACPI functions for hot plug platforms
4  *
5  * Copyright (C) 2006 Intel Corporation
6  *
7  * All rights reserved.
8  *
9  * Send feedback to <kristen.c.accardi@intel.com>
10  */
11 
12 #include <linux/module.h>
13 #include <linux/moduleparam.h>
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/pci.h>
17 #include <linux/pci_hotplug.h>
18 #include <linux/acpi.h>
19 #include <linux/pci-acpi.h>
20 #include <linux/slab.h>
21 
22 #define MY_NAME	"acpi_pcihp"
23 
24 #define dbg(fmt, arg...) do { if (debug_acpi) printk(KERN_DEBUG "%s: %s: " fmt, MY_NAME, __func__, ## arg); } while (0)
25 #define err(format, arg...) printk(KERN_ERR "%s: " format, MY_NAME, ## arg)
26 #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME, ## arg)
27 #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME, ## arg)
28 
29 #define	METHOD_NAME__SUN	"_SUN"
30 #define	METHOD_NAME_OSHP	"OSHP"
31 
32 static bool debug_acpi;
33 
34 /* acpi_run_oshp - get control of hotplug from the firmware
35  *
36  * @handle - the handle of the hotplug controller.
37  */
38 static acpi_status acpi_run_oshp(acpi_handle handle)
39 {
40 	acpi_status		status;
41 	struct acpi_buffer	string = { ACPI_ALLOCATE_BUFFER, NULL };
42 
43 	acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
44 
45 	/* run OSHP */
46 	status = acpi_evaluate_object(handle, METHOD_NAME_OSHP, NULL, NULL);
47 	if (ACPI_FAILURE(status))
48 		if (status != AE_NOT_FOUND)
49 			printk(KERN_ERR "%s:%s OSHP fails=0x%x\n",
50 			       __func__, (char *)string.pointer, status);
51 		else
52 			dbg("%s:%s OSHP not found\n",
53 			    __func__, (char *)string.pointer);
54 	else
55 		pr_debug("%s:%s OSHP passes\n", __func__,
56 			(char *)string.pointer);
57 
58 	kfree(string.pointer);
59 	return status;
60 }
61 
62 /**
63  * acpi_get_hp_hw_control_from_firmware
64  * @dev: the pci_dev of the bridge that has a hotplug controller
65  *
66  * Attempt to take hotplug control from firmware.
67  */
68 int acpi_get_hp_hw_control_from_firmware(struct pci_dev *pdev)
69 {
70 	const struct pci_host_bridge *host;
71 	const struct acpi_pci_root *root;
72 	acpi_status status;
73 	acpi_handle chandle, handle;
74 	struct acpi_buffer string = { ACPI_ALLOCATE_BUFFER, NULL };
75 
76 	/*
77 	 * Per PCI firmware specification, we should run the ACPI _OSC
78 	 * method to get control of hotplug hardware before using it. If
79 	 * an _OSC is missing, we look for an OSHP to do the same thing.
80 	 * To handle different BIOS behavior, we look for _OSC on a root
81 	 * bridge preferentially (according to PCI fw spec). Later for
82 	 * OSHP within the scope of the hotplug controller and its parents,
83 	 * up to the host bridge under which this controller exists.
84 	 */
85 	if (shpchp_is_native(pdev))
86 		return 0;
87 
88 	/* If _OSC exists, we should not evaluate OSHP */
89 
90 	/*
91 	 * If there's no ACPI host bridge (i.e., ACPI support is compiled
92 	 * into the kernel but the hardware platform doesn't support ACPI),
93 	 * there's nothing to do here.
94 	 */
95 	host = pci_find_host_bridge(pdev->bus);
96 	root = acpi_pci_find_root(ACPI_HANDLE(&host->dev));
97 	if (!root)
98 		return 0;
99 
100 	if (root->osc_support_set)
101 		goto no_control;
102 
103 	handle = ACPI_HANDLE(&pdev->dev);
104 	if (!handle) {
105 		/*
106 		 * This hotplug controller was not listed in the ACPI name
107 		 * space at all. Try to get ACPI handle of parent PCI bus.
108 		 */
109 		struct pci_bus *pbus;
110 		for (pbus = pdev->bus; pbus; pbus = pbus->parent) {
111 			handle = acpi_pci_get_bridge_handle(pbus);
112 			if (handle)
113 				break;
114 		}
115 	}
116 
117 	while (handle) {
118 		acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
119 		pci_info(pdev, "Requesting control of SHPC hotplug via OSHP (%s)\n",
120 			 (char *)string.pointer);
121 		status = acpi_run_oshp(handle);
122 		if (ACPI_SUCCESS(status))
123 			goto got_one;
124 		if (acpi_is_root_bridge(handle))
125 			break;
126 		chandle = handle;
127 		status = acpi_get_parent(chandle, &handle);
128 		if (ACPI_FAILURE(status))
129 			break;
130 	}
131 no_control:
132 	pci_info(pdev, "Cannot get control of SHPC hotplug\n");
133 	kfree(string.pointer);
134 	return -ENODEV;
135 got_one:
136 	pci_info(pdev, "Gained control of SHPC hotplug (%s)\n",
137 		 (char *)string.pointer);
138 	kfree(string.pointer);
139 	return 0;
140 }
141 EXPORT_SYMBOL(acpi_get_hp_hw_control_from_firmware);
142 
143 static int pcihp_is_ejectable(acpi_handle handle)
144 {
145 	acpi_status status;
146 	unsigned long long removable;
147 	if (!acpi_has_method(handle, "_ADR"))
148 		return 0;
149 	if (acpi_has_method(handle, "_EJ0"))
150 		return 1;
151 	status = acpi_evaluate_integer(handle, "_RMV", NULL, &removable);
152 	if (ACPI_SUCCESS(status) && removable)
153 		return 1;
154 	return 0;
155 }
156 
157 /**
158  * acpi_pcihp_check_ejectable - check if handle is ejectable ACPI PCI slot
159  * @pbus: the PCI bus of the PCI slot corresponding to 'handle'
160  * @handle: ACPI handle to check
161  *
162  * Return 1 if handle is ejectable PCI slot, 0 otherwise.
163  */
164 int acpi_pci_check_ejectable(struct pci_bus *pbus, acpi_handle handle)
165 {
166 	acpi_handle bridge_handle, parent_handle;
167 
168 	bridge_handle = acpi_pci_get_bridge_handle(pbus);
169 	if (!bridge_handle)
170 		return 0;
171 	if ((ACPI_FAILURE(acpi_get_parent(handle, &parent_handle))))
172 		return 0;
173 	if (bridge_handle != parent_handle)
174 		return 0;
175 	return pcihp_is_ejectable(handle);
176 }
177 EXPORT_SYMBOL_GPL(acpi_pci_check_ejectable);
178 
179 static acpi_status
180 check_hotplug(acpi_handle handle, u32 lvl, void *context, void **rv)
181 {
182 	int *found = (int *)context;
183 	if (pcihp_is_ejectable(handle)) {
184 		*found = 1;
185 		return AE_CTRL_TERMINATE;
186 	}
187 	return AE_OK;
188 }
189 
190 /**
191  * acpi_pci_detect_ejectable - check if the PCI bus has ejectable slots
192  * @handle - handle of the PCI bus to scan
193  *
194  * Returns 1 if the PCI bus has ACPI based ejectable slots, 0 otherwise.
195  */
196 int acpi_pci_detect_ejectable(acpi_handle handle)
197 {
198 	int found = 0;
199 
200 	if (!handle)
201 		return found;
202 
203 	acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
204 			    check_hotplug, NULL, (void *)&found, NULL);
205 	return found;
206 }
207 EXPORT_SYMBOL_GPL(acpi_pci_detect_ejectable);
208 
209 module_param(debug_acpi, bool, 0644);
210 MODULE_PARM_DESC(debug_acpi, "Debugging mode for ACPI enabled or not");
211