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
 13static 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
 89out_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 */
102void 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 */
126bool 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 */
138bool 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 */
151bool 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 */
164bool 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 */
177bool 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 */
185static 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
192static 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 */
267int 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 */
281int tb_acpi_power_off_retimers(struct tb_port *port)
282{
283	return tb_acpi_retimer_set_power(port, false);
284}
285
286static bool tb_acpi_bus_match(struct device *dev)
287{
288	return tb_is_switch(dev) || tb_is_usb4_port_device(dev);
289}
290
291static 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
311static 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
336static 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
359static 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
373static 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
380int tb_acpi_init(void)
381{
382	return register_acpi_bus_type(&tb_acpi_bus);
383}
384
385void tb_acpi_exit(void)
386{
387	unregister_acpi_bus_type(&tb_acpi_bus);
388}