1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * ACPI support
4  *
5  * Copyright (C) 2020, Intel Corporation
6  * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
7  */
8 
9 #include <linux/acpi.h>
10 
11 #include "tb.h"
12 
tb_acpi_add_link(acpi_handle handle,u32 level,void * data,void ** return_value)13 static acpi_status tb_acpi_add_link(acpi_handle handle, u32 level, void *data,
14 				    void **return_value)
15 {
16 	struct fwnode_reference_args args;
17 	struct fwnode_handle *fwnode;
18 	struct tb_nhi *nhi = data;
19 	struct acpi_device *adev;
20 	struct pci_dev *pdev;
21 	struct device *dev;
22 	int ret;
23 
24 	if (acpi_bus_get_device(handle, &adev))
25 		return AE_OK;
26 
27 	fwnode = acpi_fwnode_handle(adev);
28 	ret = fwnode_property_get_reference_args(fwnode, "usb4-host-interface",
29 						 NULL, 0, 0, &args);
30 	if (ret)
31 		return AE_OK;
32 
33 	/* It needs to reference this NHI */
34 	if (nhi->pdev->dev.fwnode != args.fwnode)
35 		goto out_put;
36 
37 	/*
38 	 * Try to find physical device walking upwards to the hierarcy.
39 	 * We need to do this because the xHCI driver might not yet be
40 	 * bound so the USB3 SuperSpeed ports are not yet created.
41 	 */
42 	dev = acpi_get_first_physical_node(adev);
43 	while (!dev) {
44 		adev = adev->parent;
45 		if (!adev)
46 			break;
47 		dev = acpi_get_first_physical_node(adev);
48 	}
49 
50 	if (!dev)
51 		goto out_put;
52 
53 	/*
54 	 * Check that the device is PCIe. This is because USB3
55 	 * SuperSpeed ports have this property and they are not power
56 	 * managed with the xHCI and the SuperSpeed hub so we create the
57 	 * link from xHCI instead.
58 	 */
59 	while (dev && !dev_is_pci(dev))
60 		dev = dev->parent;
61 
62 	if (!dev)
63 		goto out_put;
64 
65 	/*
66 	 * Check that this actually matches the type of device we
67 	 * expect. It should either be xHCI or PCIe root/downstream
68 	 * port.
69 	 */
70 	pdev = to_pci_dev(dev);
71 	if (pdev->class == PCI_CLASS_SERIAL_USB_XHCI ||
72 	    (pci_is_pcie(pdev) &&
73 		(pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT ||
74 		 pci_pcie_type(pdev) == PCI_EXP_TYPE_DOWNSTREAM))) {
75 		const struct device_link *link;
76 
77 		link = device_link_add(&pdev->dev, &nhi->pdev->dev,
78 				       DL_FLAG_AUTOREMOVE_SUPPLIER |
79 				       DL_FLAG_PM_RUNTIME);
80 		if (link) {
81 			dev_dbg(&nhi->pdev->dev, "created link from %s\n",
82 				dev_name(&pdev->dev));
83 		} else {
84 			dev_warn(&nhi->pdev->dev, "device link creation from %s failed\n",
85 				 dev_name(&pdev->dev));
86 		}
87 	}
88 
89 out_put:
90 	fwnode_handle_put(args.fwnode);
91 	return AE_OK;
92 }
93 
94 /**
95  * tb_acpi_add_links() - Add device links based on ACPI description
96  * @nhi: Pointer to NHI
97  *
98  * Goes over ACPI namespace finding tunneled ports that reference to
99  * @nhi ACPI node. For each reference a device link is added. The link
100  * is automatically removed by the driver core.
101  */
tb_acpi_add_links(struct tb_nhi * nhi)102 void tb_acpi_add_links(struct tb_nhi *nhi)
103 {
104 	acpi_status status;
105 
106 	if (!has_acpi_companion(&nhi->pdev->dev))
107 		return;
108 
109 	/*
110 	 * Find all devices that have usb4-host-controller interface
111 	 * property that references to this NHI.
112 	 */
113 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 32,
114 				     tb_acpi_add_link, NULL, nhi, NULL);
115 	if (ACPI_FAILURE(status))
116 		dev_warn(&nhi->pdev->dev, "failed to enumerate tunneled ports\n");
117 }
118 
119 /**
120  * tb_acpi_is_native() - Did the platform grant native TBT/USB4 control
121  *
122  * Returns %true if the platform granted OS native control over
123  * TBT/USB4. In this case software based connection manager can be used,
124  * otherwise there is firmware based connection manager running.
125  */
tb_acpi_is_native(void)126 bool tb_acpi_is_native(void)
127 {
128 	return osc_sb_native_usb4_support_confirmed &&
129 	       osc_sb_native_usb4_control;
130 }
131 
132 /**
133  * tb_acpi_may_tunnel_usb3() - Is USB3 tunneling allowed by the platform
134  *
135  * When software based connection manager is used, this function
136  * returns %true if platform allows native USB3 tunneling.
137  */
tb_acpi_may_tunnel_usb3(void)138 bool tb_acpi_may_tunnel_usb3(void)
139 {
140 	if (tb_acpi_is_native())
141 		return osc_sb_native_usb4_control & OSC_USB_USB3_TUNNELING;
142 	return true;
143 }
144 
145 /**
146  * tb_acpi_may_tunnel_dp() - Is DisplayPort tunneling allowed by the platform
147  *
148  * When software based connection manager is used, this function
149  * returns %true if platform allows native DP tunneling.
150  */
tb_acpi_may_tunnel_dp(void)151 bool tb_acpi_may_tunnel_dp(void)
152 {
153 	if (tb_acpi_is_native())
154 		return osc_sb_native_usb4_control & OSC_USB_DP_TUNNELING;
155 	return true;
156 }
157 
158 /**
159  * tb_acpi_may_tunnel_pcie() - Is PCIe tunneling allowed by the platform
160  *
161  * When software based connection manager is used, this function
162  * returns %true if platform allows native PCIe tunneling.
163  */
tb_acpi_may_tunnel_pcie(void)164 bool tb_acpi_may_tunnel_pcie(void)
165 {
166 	if (tb_acpi_is_native())
167 		return osc_sb_native_usb4_control & OSC_USB_PCIE_TUNNELING;
168 	return true;
169 }
170 
171 /**
172  * tb_acpi_is_xdomain_allowed() - Are XDomain connections allowed
173  *
174  * When software based connection manager is used, this function
175  * returns %true if platform allows XDomain connections.
176  */
tb_acpi_is_xdomain_allowed(void)177 bool tb_acpi_is_xdomain_allowed(void)
178 {
179 	if (tb_acpi_is_native())
180 		return osc_sb_native_usb4_control & OSC_USB_XDOMAIN;
181 	return true;
182 }
183 
184 /* UUID for retimer _DSM: e0053122-795b-4122-8a5e-57be1d26acb3 */
185 static const guid_t retimer_dsm_guid =
186 	GUID_INIT(0xe0053122, 0x795b, 0x4122,
187 		  0x8a, 0x5e, 0x57, 0xbe, 0x1d, 0x26, 0xac, 0xb3);
188 
189 #define RETIMER_DSM_QUERY_ONLINE_STATE	1
190 #define RETIMER_DSM_SET_ONLINE_STATE	2
191 
tb_acpi_retimer_set_power(struct tb_port * port,bool power)192 static int tb_acpi_retimer_set_power(struct tb_port *port, bool power)
193 {
194 	struct usb4_port *usb4 = port->usb4;
195 	union acpi_object argv4[2];
196 	struct acpi_device *adev;
197 	union acpi_object *obj;
198 	int ret;
199 
200 	if (!usb4->can_offline)
201 		return 0;
202 
203 	adev = ACPI_COMPANION(&usb4->dev);
204 	if (WARN_ON(!adev))
205 		return 0;
206 
207 	/* Check if we are already powered on (and in correct mode) */
208 	obj = acpi_evaluate_dsm_typed(adev->handle, &retimer_dsm_guid, 1,
209 				      RETIMER_DSM_QUERY_ONLINE_STATE, NULL,
210 				      ACPI_TYPE_INTEGER);
211 	if (!obj) {
212 		tb_port_warn(port, "ACPI: query online _DSM failed\n");
213 		return -EIO;
214 	}
215 
216 	ret = obj->integer.value;
217 	ACPI_FREE(obj);
218 
219 	if (power == ret)
220 		return 0;
221 
222 	tb_port_dbg(port, "ACPI: calling _DSM to power %s retimers\n",
223 		    power ? "on" : "off");
224 
225 	argv4[0].type = ACPI_TYPE_PACKAGE;
226 	argv4[0].package.count = 1;
227 	argv4[0].package.elements = &argv4[1];
228 	argv4[1].integer.type = ACPI_TYPE_INTEGER;
229 	argv4[1].integer.value = power;
230 
231 	obj = acpi_evaluate_dsm_typed(adev->handle, &retimer_dsm_guid, 1,
232 				      RETIMER_DSM_SET_ONLINE_STATE, argv4,
233 				      ACPI_TYPE_INTEGER);
234 	if (!obj) {
235 		tb_port_warn(port,
236 			     "ACPI: set online state _DSM evaluation failed\n");
237 		return -EIO;
238 	}
239 
240 	ret = obj->integer.value;
241 	ACPI_FREE(obj);
242 
243 	if (ret >= 0) {
244 		if (power)
245 			return ret == 1 ? 0 : -EBUSY;
246 		return 0;
247 	}
248 
249 	tb_port_warn(port, "ACPI: set online state _DSM failed with error %d\n", ret);
250 	return -EIO;
251 }
252 
253 /**
254  * tb_acpi_power_on_retimers() - Call platform to power on retimers
255  * @port: USB4 port
256  *
257  * Calls platform to turn on power to all retimers behind this USB4
258  * port. After this function returns successfully the caller can
259  * continue with the normal retimer flows (as specified in the USB4
260  * spec). Note if this returns %-EBUSY it means the type-C port is in
261  * non-USB4/TBT mode (there is non-USB4/TBT device connected).
262  *
263  * This should only be called if the USB4/TBT link is not up.
264  *
265  * Returns %0 on success.
266  */
tb_acpi_power_on_retimers(struct tb_port * port)267 int tb_acpi_power_on_retimers(struct tb_port *port)
268 {
269 	return tb_acpi_retimer_set_power(port, true);
270 }
271 
272 /**
273  * tb_acpi_power_off_retimers() - Call platform to power off retimers
274  * @port: USB4 port
275  *
276  * This is the opposite of tb_acpi_power_on_retimers(). After returning
277  * successfully the normal operations with the @port can continue.
278  *
279  * Returns %0 on success.
280  */
tb_acpi_power_off_retimers(struct tb_port * port)281 int tb_acpi_power_off_retimers(struct tb_port *port)
282 {
283 	return tb_acpi_retimer_set_power(port, false);
284 }
285 
tb_acpi_bus_match(struct device * dev)286 static bool tb_acpi_bus_match(struct device *dev)
287 {
288 	return tb_is_switch(dev) || tb_is_usb4_port_device(dev);
289 }
290 
tb_acpi_find_port(struct acpi_device * adev,const struct tb_port * port)291 static struct acpi_device *tb_acpi_find_port(struct acpi_device *adev,
292 					     const struct tb_port *port)
293 {
294 	struct acpi_device *port_adev;
295 
296 	if (!adev)
297 		return NULL;
298 
299 	/*
300 	 * Device routers exists under the downstream facing USB4 port
301 	 * of the parent router. Their _ADR is always 0.
302 	 */
303 	list_for_each_entry(port_adev, &adev->children, node) {
304 		if (acpi_device_adr(port_adev) == port->port)
305 			return port_adev;
306 	}
307 
308 	return NULL;
309 }
310 
tb_acpi_switch_find_companion(struct tb_switch * sw)311 static struct acpi_device *tb_acpi_switch_find_companion(struct tb_switch *sw)
312 {
313 	struct acpi_device *adev = NULL;
314 	struct tb_switch *parent_sw;
315 
316 	parent_sw = tb_switch_parent(sw);
317 	if (parent_sw) {
318 		struct tb_port *port = tb_port_at(tb_route(sw), parent_sw);
319 		struct acpi_device *port_adev;
320 
321 		port_adev = tb_acpi_find_port(ACPI_COMPANION(&parent_sw->dev), port);
322 		if (port_adev)
323 			adev = acpi_find_child_device(port_adev, 0, false);
324 	} else {
325 		struct tb_nhi *nhi = sw->tb->nhi;
326 		struct acpi_device *parent_adev;
327 
328 		parent_adev = ACPI_COMPANION(&nhi->pdev->dev);
329 		if (parent_adev)
330 			adev = acpi_find_child_device(parent_adev, 0, false);
331 	}
332 
333 	return adev;
334 }
335 
tb_acpi_find_companion(struct device * dev)336 static struct acpi_device *tb_acpi_find_companion(struct device *dev)
337 {
338 	/*
339 	 * The Thunderbolt/USB4 hierarchy looks like following:
340 	 *
341 	 * Device (NHI)
342 	 *   Device (HR)		// Host router _ADR == 0
343 	 *      Device (DFP0)		// Downstream port _ADR == lane 0 adapter
344 	 *        Device (DR)		// Device router _ADR == 0
345 	 *          Device (UFP)	// Upstream port _ADR == lane 0 adapter
346 	 *      Device (DFP1)		// Downstream port _ADR == lane 0 adapter number
347 	 *
348 	 * At the moment we bind the host router to the corresponding
349 	 * Linux device.
350 	 */
351 	if (tb_is_switch(dev))
352 		return tb_acpi_switch_find_companion(tb_to_switch(dev));
353 	else if (tb_is_usb4_port_device(dev))
354 		return tb_acpi_find_port(ACPI_COMPANION(dev->parent),
355 					 tb_to_usb4_port_device(dev)->port);
356 	return NULL;
357 }
358 
tb_acpi_setup(struct device * dev)359 static void tb_acpi_setup(struct device *dev)
360 {
361 	struct acpi_device *adev = ACPI_COMPANION(dev);
362 	struct usb4_port *usb4 = tb_to_usb4_port_device(dev);
363 
364 	if (!adev || !usb4)
365 		return;
366 
367 	if (acpi_check_dsm(adev->handle, &retimer_dsm_guid, 1,
368 			   BIT(RETIMER_DSM_QUERY_ONLINE_STATE) |
369 			   BIT(RETIMER_DSM_SET_ONLINE_STATE)))
370 		usb4->can_offline = true;
371 }
372 
373 static struct acpi_bus_type tb_acpi_bus = {
374 	.name = "thunderbolt",
375 	.match = tb_acpi_bus_match,
376 	.find_companion = tb_acpi_find_companion,
377 	.setup = tb_acpi_setup,
378 };
379 
tb_acpi_init(void)380 int tb_acpi_init(void)
381 {
382 	return register_acpi_bus_type(&tb_acpi_bus);
383 }
384 
tb_acpi_exit(void)385 void tb_acpi_exit(void)
386 {
387 	unregister_acpi_bus_type(&tb_acpi_bus);
388 }
389