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