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