// SPDX-License-Identifier: GPL-2.0/* * Thunderbolt/USB4 retimer support. * * Copyright (C) 2020, Intel Corporation * Authors: Kranthi Kuntala <kranthi.kuntala@intel.com> * Mika Westerberg <mika.westerberg@linux.intel.com> */ #include <linux/delay.h>#include <linux/pm_runtime.h>#include <linux/sched/signal.h> #include "sb_regs.h"#include "tb.h" #if IS_ENABLED(CONFIG_USB4_DEBUGFS_MARGINING)#define TB_MAX_RETIMER_INDEX 6#else#define TB_MAX_RETIMER_INDEX 2#endif /** * tb_retimer_nvm_read() - Read contents of retimer NVM * @rt: Retimer device * @address: NVM address (in bytes) to start reading * @buf: Data read from NVM is stored here * @size: Number of bytes to read * * Reads retimer NVM and copies the contents to @buf. * * Return: %0 if the read was successful, negative errno in case of failure. */int tb_retimer_nvm_read(struct tb_retimer *rt, unsigned int address, void *buf, size_t size){ return usb4_port_retimer_nvm_read(rt->port, rt->index, address, buf, size);} static int nvm_read(void *priv, unsigned int offset, void *val, size_t bytes){ struct tb_nvm *nvm = priv; struct tb_retimer *rt = tb_to_retimer(nvm->dev); int ret; pm_runtime_get_sync(&rt->dev); if (!mutex_trylock(&rt->tb->lock)) { ret = restart_syscall(); goto out; } ret = tb_retimer_nvm_read(rt, offset, val, bytes); mutex_unlock(&rt->tb->lock); out: pm_runtime_mark_last_busy(&rt->dev); pm_runtime_put_autosuspend(&rt->dev); return ret;} static int nvm_write(void *priv, unsigned int offset, void *val, size_t bytes){ struct tb_nvm *nvm = priv; struct tb_retimer *rt = tb_to_retimer(nvm->dev); int ret = 0; if (!mutex_trylock(&rt->tb->lock)) return restart_syscall(); ret = tb_nvm_write_buf(nvm, offset, val, bytes); mutex_unlock(&rt->tb->lock); return ret;} static int tb_retimer_nvm_add(struct tb_retimer *rt){ struct tb_nvm *nvm; int ret; nvm = tb_nvm_alloc(&rt->dev); if (IS_ERR(nvm)) { ret = PTR_ERR(nvm) == -EOPNOTSUPP ? 0 : PTR_ERR(nvm); goto err_nvm; } ret = tb_nvm_read_version(nvm); if (ret) goto err_nvm; ret = tb_nvm_add_active(nvm, nvm_read); if (ret) goto err_nvm; if (!rt->no_nvm_upgrade) { ret = tb_nvm_add_non_active(nvm, nvm_write); if (ret) goto err_nvm; } rt->nvm = nvm; dev_dbg(&rt->dev, "NVM version %x.%x\n", nvm->major, nvm->minor); return 0; err_nvm: dev_dbg(&rt->dev, "NVM upgrade disabled\n"); rt->no_nvm_upgrade = true; if (!IS_ERR(nvm)) tb_nvm_free(nvm); return ret;} static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt){ unsigned int image_size; const u8 *buf; int ret; ret = tb_nvm_validate(rt->nvm); if (ret) return ret; buf = rt->nvm->buf_data_start; image_size = rt->nvm->buf_data_size; ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf, image_size); if (ret) return ret; rt->nvm->flushed = true; return 0;} static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only){ u32 status; int ret; if (auth_only) { ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0); if (ret) return ret; } ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index); if (ret) return ret; usleep_range(100, 150); /* * Check the status now if we still can access the retimer. It * is expected that the below fails. */ ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index, &status); if (!ret) { rt->auth_status = status; return status ? -EINVAL : 0; } return 0;} static ssize_t device_show(struct device *dev, struct device_attribute *attr, char *buf){ struct tb_retimer *rt = tb_to_retimer(dev); return sysfs_emit(buf, "%#x\n", rt->device);}static DEVICE_ATTR_RO(device); static ssize_t nvm_authenticate_show(struct device *dev, struct device_attribute *attr, char *buf){ struct tb_retimer *rt = tb_to_retimer(dev); int ret; if (!mutex_trylock(&rt->tb->lock)) return restart_syscall(); if (!rt->nvm) ret = -EAGAIN; else ret = sysfs_emit(buf, "%#x\n", rt->auth_status); mutex_unlock(&rt->tb->lock); return ret;} static void tb_retimer_nvm_authenticate_status(struct tb_port *port, u32 *status){ int i; tb_port_dbg(port, "reading NVM authentication status of retimers\n"); /* * Before doing anything else, read the authentication status. * If the retimer has it set, store it for the new retimer * device instance. */ for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) { if (usb4_port_retimer_nvm_authenticate_status(port, i, &status[i])) break; }} static void tb_retimer_set_inbound_sbtx(struct tb_port *port){ int i; /* * When USB4 port is online sideband communications are * already up. */ if (!usb4_port_device_is_offline(port->usb4)) return; tb_port_dbg(port, "enabling sideband transactions\n"); for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) usb4_port_retimer_set_inbound_sbtx(port, i);} static void tb_retimer_unset_inbound_sbtx(struct tb_port *port){ int i; /* * When USB4 port is offline we need to keep the sideband * communications up to make it possible to communicate with * the connected retimers. */ if (usb4_port_device_is_offline(port->usb4)) return; tb_port_dbg(port, "disabling sideband transactions\n"); for (i = TB_MAX_RETIMER_INDEX; i >= 1; i--) { if (usb4_port_retimer_unset_inbound_sbtx(port, i)) break; }} static ssize_t nvm_authenticate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count){ struct tb_retimer *rt = tb_to_retimer(dev); int val, ret; pm_runtime_get_sync(&rt->dev); if (!mutex_trylock(&rt->tb->lock)) { ret = restart_syscall(); goto exit_rpm; } if (!rt->nvm) { ret = -EAGAIN; goto exit_unlock; } ret = kstrtoint(buf, 10, &val); if (ret) goto exit_unlock; /* Always clear status */ rt->auth_status = 0; if (val) { /* * When NVM authentication starts the retimer is not * accessible so calling tb_retimer_unset_inbound_sbtx() * will fail and therefore we do not call it. Exception * is when the validation fails or we only write the new * NVM image without authentication. */ tb_retimer_set_inbound_sbtx(rt->port); if (val == AUTHENTICATE_ONLY) { ret = tb_retimer_nvm_authenticate(rt, true); } else { if (!rt->nvm->flushed) { if (!rt->nvm->buf) { ret = -EINVAL; goto exit_unlock; } ret = tb_retimer_nvm_validate_and_write(rt); if (ret || val == WRITE_ONLY) goto exit_unlock; } if (val == WRITE_AND_AUTHENTICATE) ret = tb_retimer_nvm_authenticate(rt, false); } } exit_unlock: if (ret || val == WRITE_ONLY) tb_retimer_unset_inbound_sbtx(rt->port); mutex_unlock(&rt->tb->lock);exit_rpm: pm_runtime_mark_last_busy(&rt->dev); pm_runtime_put_autosuspend(&rt->dev); if (ret) return ret; return count;}static DEVICE_ATTR_RW(nvm_authenticate); static ssize_t nvm_version_show(struct device *dev, struct device_attribute *attr, char *buf){ struct tb_retimer *rt = tb_to_retimer(dev); int ret; if (!mutex_trylock(&rt->tb->lock)) return restart_syscall(); if (!rt->nvm) ret = -EAGAIN; else ret = sysfs_emit(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor); mutex_unlock(&rt->tb->lock); return ret;}static DEVICE_ATTR_RO(nvm_version); static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, char *buf){ struct tb_retimer *rt = tb_to_retimer(dev); return sysfs_emit(buf, "%#x\n", rt->vendor);}static DEVICE_ATTR_RO(vendor); static umode_t retimer_is_visible(struct kobject *kobj, struct attribute *attr, int n){ struct device *dev = kobj_to_dev(kobj); struct tb_retimer *rt = tb_to_retimer(dev); if (attr == &dev_attr_nvm_authenticate.attr || attr == &dev_attr_nvm_version.attr) return rt->no_nvm_upgrade ? 0 : attr->mode; return attr->mode;} static struct attribute *retimer_attrs[] = { &dev_attr_device.attr, &dev_attr_nvm_authenticate.attr, &dev_attr_nvm_version.attr, &dev_attr_vendor.attr, NULL}; static const struct attribute_group retimer_group = { .is_visible = retimer_is_visible, .attrs = retimer_attrs,}; static const struct attribute_group *retimer_groups[] = { &retimer_group, NULL}; static void tb_retimer_release(struct device *dev){ struct tb_retimer *rt = tb_to_retimer(dev); kfree(rt);} const struct device_type tb_retimer_type = { .name = "thunderbolt_retimer", .groups = retimer_groups, .release = tb_retimer_release,}; static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status, bool on_board){ struct tb_retimer *rt; u32 vendor, device; int ret; ret = usb4_port_sb_read(port, USB4_SB_TARGET_RETIMER, index, USB4_SB_VENDOR_ID, &vendor, sizeof(vendor)); if (ret) { if (ret != -ENODEV) tb_port_warn(port, "failed read retimer VendorId: %d\n", ret); return ret; } ret = usb4_port_sb_read(port, USB4_SB_TARGET_RETIMER, index, USB4_SB_PRODUCT_ID, &device, sizeof(device)); if (ret) { if (ret != -ENODEV) tb_port_warn(port, "failed read retimer ProductId: %d\n", ret); return ret; } rt = kzalloc_obj(*rt); if (!rt) return -ENOMEM; rt->index = index; rt->vendor = vendor; rt->device = device; rt->auth_status = auth_status; rt->port = port; rt->tb = port->sw->tb; /* * Only support NVM upgrade for on-board retimers. The retimers * on the other side of the connection. */ if (!on_board || usb4_port_retimer_nvm_sector_size(port, index) <= 0) rt->no_nvm_upgrade = true; rt->dev.parent = &port->usb4->dev; rt->dev.bus = &tb_bus_type; rt->dev.type = &tb_retimer_type; dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev), port->port, index); ret = device_register(&rt->dev); if (ret) { dev_err(&rt->dev, "failed to register retimer: %d\n", ret); put_device(&rt->dev); return ret; } ret = tb_retimer_nvm_add(rt); if (ret) { dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret); device_unregister(&rt->dev); return ret; } dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n", rt->vendor, rt->device); pm_runtime_no_callbacks(&rt->dev); pm_runtime_set_active(&rt->dev); pm_runtime_enable(&rt->dev); pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY); pm_runtime_mark_last_busy(&rt->dev); pm_runtime_use_autosuspend(&rt->dev); tb_retimer_debugfs_init(rt); return 0;} static void tb_retimer_remove(struct tb_retimer *rt){ dev_info(&rt->dev, "retimer disconnected\n"); tb_retimer_debugfs_remove(rt); tb_nvm_free(rt->nvm); device_unregister(&rt->dev);} struct tb_retimer_lookup { const struct tb_port *port; u8 index;}; static int retimer_match(struct device *dev, const void *data){ const struct tb_retimer_lookup *lookup = data; struct tb_retimer *rt = tb_to_retimer(dev); return rt && rt->port == lookup->port && rt->index == lookup->index;} static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index){ struct tb_retimer_lookup lookup = { .port = port, .index = index }; struct device *dev; dev = device_find_child(&port->usb4->dev, &lookup, retimer_match); if (dev) return tb_to_retimer(dev); return NULL;} /** * tb_retimer_scan() - Scan for on-board retimers under port * @port: USB4 port to scanLines 1–500 of 600. Load more
// SPDX-License-Identifier: GPL-2.0 /* * Thunderbolt/USB4 retimer support. * * Copyright (C) 2020, Intel Corporation * Authors: Kranthi Kuntala <kranthi.kuntala@intel.com> * Mika Westerberg <mika.westerberg@linux.intel.com> */ #include <linux/delay.h> #include <linux/pm_runtime.h> #include <linux/sched/signal.h> #include "sb_regs.h" #include "tb.h" #if IS_ENABLED(CONFIG_USB4_DEBUGFS_MARGINING) #define TB_MAX_RETIMER_INDEX 6 #else #define TB_MAX_RETIMER_INDEX 2 #endif /** * tb_retimer_nvm_read() - Read contents of retimer NVM * @rt: Retimer device * @address: NVM address (in bytes) to start reading * @buf: Data read from NVM is stored here * @size: Number of bytes to read * * Reads retimer NVM and copies the contents to @buf. * * Return: %0 if the read was successful, negative errno in case of failure. */ int tb_retimer_nvm_read(struct tb_retimer *rt, unsigned int address, void *buf, size_t size) { return usb4_port_retimer_nvm_read(rt->port, rt->index, address, buf, size); } static int nvm_read(void *priv, unsigned int offset, void *val, size_t bytes) { struct tb_nvm *nvm = priv; struct tb_retimer *rt = tb_to_retimer(nvm->dev); int ret; pm_runtime_get_sync(&rt->dev); if (!mutex_trylock(&rt->tb->lock)) { ret = restart_syscall(); goto out; } ret = tb_retimer_nvm_read(rt, offset, val, bytes); mutex_unlock(&rt->tb->lock); out: pm_runtime_mark_last_busy(&rt->dev); pm_runtime_put_autosuspend(&rt->dev); return ret; } static int nvm_write(void *priv, unsigned int offset, void *val, size_t bytes) { struct tb_nvm *nvm = priv; struct tb_retimer *rt = tb_to_retimer(nvm->dev); int ret = 0; if (!mutex_trylock(&rt->tb->lock)) return restart_syscall(); ret = tb_nvm_write_buf(nvm, offset, val, bytes); mutex_unlock(&rt->tb->lock); return ret; } static int tb_retimer_nvm_add(struct tb_retimer *rt) { struct tb_nvm *nvm; int ret; nvm = tb_nvm_alloc(&rt->dev); if (IS_ERR(nvm)) { ret = PTR_ERR(nvm) == -EOPNOTSUPP ? 0 : PTR_ERR(nvm); goto err_nvm; } ret = tb_nvm_read_version(nvm); if (ret) goto err_nvm; ret = tb_nvm_add_active(nvm, nvm_read); if (ret) goto err_nvm; if (!rt->no_nvm_upgrade) { ret = tb_nvm_add_non_active(nvm, nvm_write); if (ret) goto err_nvm; } rt->nvm = nvm; dev_dbg(&rt->dev, "NVM version %x.%x\n", nvm->major, nvm->minor); return 0; err_nvm: dev_dbg(&rt->dev, "NVM upgrade disabled\n"); rt->no_nvm_upgrade = true; if (!IS_ERR(nvm)) tb_nvm_free(nvm); return ret; } static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt) { unsigned int image_size; const u8 *buf; int ret; ret = tb_nvm_validate(rt->nvm); if (ret) return ret; buf = rt->nvm->buf_data_start; image_size = rt->nvm->buf_data_size; ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf, image_size); if (ret) return ret; rt->nvm->flushed = true; return 0; } static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only) { u32 status; int ret; if (auth_only) { ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0); if (ret) return ret; } ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index); if (ret) return ret; usleep_range(100, 150); /* * Check the status now if we still can access the retimer. It * is expected that the below fails. */ ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index, &status); if (!ret) { rt->auth_status = status; return status ? -EINVAL : 0; } return 0; } static ssize_t device_show(struct device *dev, struct device_attribute *attr, char *buf) { struct tb_retimer *rt = tb_to_retimer(dev); return sysfs_emit(buf, "%#x\n", rt->device); } static DEVICE_ATTR_RO(device); static ssize_t nvm_authenticate_show(struct device *dev, struct device_attribute *attr, char *buf) { struct tb_retimer *rt = tb_to_retimer(dev); int ret; if (!mutex_trylock(&rt->tb->lock)) return restart_syscall(); if (!rt->nvm) ret = -EAGAIN; else ret = sysfs_emit(buf, "%#x\n", rt->auth_status); mutex_unlock(&rt->tb->lock); return ret; } static void tb_retimer_nvm_authenticate_status(struct tb_port *port, u32 *status) { int i; tb_port_dbg(port, "reading NVM authentication status of retimers\n"); /* * Before doing anything else, read the authentication status. * If the retimer has it set, store it for the new retimer * device instance. */ for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) { if (usb4_port_retimer_nvm_authenticate_status(port, i, &status[i])) break; } } static void tb_retimer_set_inbound_sbtx(struct tb_port *port) { int i; /* * When USB4 port is online sideband communications are * already up. */ if (!usb4_port_device_is_offline(port->usb4)) return; tb_port_dbg(port, "enabling sideband transactions\n"); for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) usb4_port_retimer_set_inbound_sbtx(port, i); } static void tb_retimer_unset_inbound_sbtx(struct tb_port *port) { int i; /* * When USB4 port is offline we need to keep the sideband * communications up to make it possible to communicate with * the connected retimers. */ if (usb4_port_device_is_offline(port->usb4)) return; tb_port_dbg(port, "disabling sideband transactions\n"); for (i = TB_MAX_RETIMER_INDEX; i >= 1; i--) { if (usb4_port_retimer_unset_inbound_sbtx(port, i)) break; } } static ssize_t nvm_authenticate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct tb_retimer *rt = tb_to_retimer(dev); int val, ret; pm_runtime_get_sync(&rt->dev); if (!mutex_trylock(&rt->tb->lock)) { ret = restart_syscall(); goto exit_rpm; } if (!rt->nvm) { ret = -EAGAIN; goto exit_unlock; } ret = kstrtoint(buf, 10, &val); if (ret) goto exit_unlock; /* Always clear status */ rt->auth_status = 0; if (val) { /* * When NVM authentication starts the retimer is not * accessible so calling tb_retimer_unset_inbound_sbtx() * will fail and therefore we do not call it. Exception * is when the validation fails or we only write the new * NVM image without authentication. */ tb_retimer_set_inbound_sbtx(rt->port); if (val == AUTHENTICATE_ONLY) { ret = tb_retimer_nvm_authenticate(rt, true); } else { if (!rt->nvm->flushed) { if (!rt->nvm->buf) { ret = -EINVAL; goto exit_unlock; } ret = tb_retimer_nvm_validate_and_write(rt); if (ret || val == WRITE_ONLY) goto exit_unlock; } if (val == WRITE_AND_AUTHENTICATE) ret = tb_retimer_nvm_authenticate(rt, false); } } exit_unlock: if (ret || val == WRITE_ONLY) tb_retimer_unset_inbound_sbtx(rt->port); mutex_unlock(&rt->tb->lock); exit_rpm: pm_runtime_mark_last_busy(&rt->dev); pm_runtime_put_autosuspend(&rt->dev); if (ret) return ret; return count; } static DEVICE_ATTR_RW(nvm_authenticate); static ssize_t nvm_version_show(struct device *dev, struct device_attribute *attr, char *buf) { struct tb_retimer *rt = tb_to_retimer(dev); int ret; if (!mutex_trylock(&rt->tb->lock)) return restart_syscall(); if (!rt->nvm) ret = -EAGAIN; else ret = sysfs_emit(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor); mutex_unlock(&rt->tb->lock); return ret; } static DEVICE_ATTR_RO(nvm_version); static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, char *buf) { struct tb_retimer *rt = tb_to_retimer(dev); return sysfs_emit(buf, "%#x\n", rt->vendor); } static DEVICE_ATTR_RO(vendor); static umode_t retimer_is_visible(struct kobject *kobj, struct attribute *attr, int n) { struct device *dev = kobj_to_dev(kobj); struct tb_retimer *rt = tb_to_retimer(dev); if (attr == &dev_attr_nvm_authenticate.attr || attr == &dev_attr_nvm_version.attr) return rt->no_nvm_upgrade ? 0 : attr->mode; return attr->mode; } static struct attribute *retimer_attrs[] = { &dev_attr_device.attr, &dev_attr_nvm_authenticate.attr, &dev_attr_nvm_version.attr, &dev_attr_vendor.attr, NULL }; static const struct attribute_group retimer_group = { .is_visible = retimer_is_visible, .attrs = retimer_attrs, }; static const struct attribute_group *retimer_groups[] = { &retimer_group, NULL }; static void tb_retimer_release(struct device *dev) { struct tb_retimer *rt = tb_to_retimer(dev); kfree(rt); } const struct device_type tb_retimer_type = { .name = "thunderbolt_retimer", .groups = retimer_groups, .release = tb_retimer_release, }; static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status, bool on_board) { struct tb_retimer *rt; u32 vendor, device; int ret; ret = usb4_port_sb_read(port, USB4_SB_TARGET_RETIMER, index, USB4_SB_VENDOR_ID, &vendor, sizeof(vendor)); if (ret) { if (ret != -ENODEV) tb_port_warn(port, "failed read retimer VendorId: %d\n", ret); return ret; } ret = usb4_port_sb_read(port, USB4_SB_TARGET_RETIMER, index, USB4_SB_PRODUCT_ID, &device, sizeof(device)); if (ret) { if (ret != -ENODEV) tb_port_warn(port, "failed read retimer ProductId: %d\n", ret); return ret; } rt = kzalloc_obj(*rt); if (!rt) return -ENOMEM; rt->index = index; rt->vendor = vendor; rt->device = device; rt->auth_status = auth_status; rt->port = port; rt->tb = port->sw->tb; /* * Only support NVM upgrade for on-board retimers. The retimers * on the other side of the connection. */ if (!on_board || usb4_port_retimer_nvm_sector_size(port, index) <= 0) rt->no_nvm_upgrade = true; rt->dev.parent = &port->usb4->dev; rt->dev.bus = &tb_bus_type; rt->dev.type = &tb_retimer_type; dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev), port->port, index); ret = device_register(&rt->dev); if (ret) { dev_err(&rt->dev, "failed to register retimer: %d\n", ret); put_device(&rt->dev); return ret; } ret = tb_retimer_nvm_add(rt); if (ret) { dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret); device_unregister(&rt->dev); return ret; } dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n", rt->vendor, rt->device); pm_runtime_no_callbacks(&rt->dev); pm_runtime_set_active(&rt->dev); pm_runtime_enable(&rt->dev); pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY); pm_runtime_mark_last_busy(&rt->dev); pm_runtime_use_autosuspend(&rt->dev); tb_retimer_debugfs_init(rt); return 0; } static void tb_retimer_remove(struct tb_retimer *rt) { dev_info(&rt->dev, "retimer disconnected\n"); tb_retimer_debugfs_remove(rt); tb_nvm_free(rt->nvm); device_unregister(&rt->dev); } struct tb_retimer_lookup { const struct tb_port *port; u8 index; }; static int retimer_match(struct device *dev, const void *data) { const struct tb_retimer_lookup *lookup = data; struct tb_retimer *rt = tb_to_retimer(dev); return rt && rt->port == lookup->port && rt->index == lookup->index; } static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index) { struct tb_retimer_lookup lookup = { .port = port, .index = index }; struct device *dev; dev = device_find_child(&port->usb4->dev, &lookup, retimer_match); if (dev) return tb_to_retimer(dev); return NULL; } /** * tb_retimer_scan() - Scan for on-board retimers under port * @port: USB4 port to scan