1 // SPDX-License-Identifier: GPL-2.0
3 * Thunderbolt/USB4 retimer support.
5 * Copyright (C) 2020, Intel Corporation
6 * Authors: Kranthi Kuntala <kranthi.kuntala@intel.com>
7 * Mika Westerberg <mika.westerberg@linux.intel.com>
10 #include <linux/delay.h>
11 #include <linux/pm_runtime.h>
12 #include <linux/sched/signal.h>
17 #define TB_MAX_RETIMER_INDEX 6
20 * tb_retimer_nvm_read() - Read contents of retimer NVM
22 * @address: NVM address (in bytes) to start reading
23 * @buf: Data read from NVM is stored here
24 * @size: Number of bytes to read
26 * Reads retimer NVM and copies the contents to @buf. Returns %0 if the
27 * read was successful and negative errno in case of failure.
29 int tb_retimer_nvm_read(struct tb_retimer *rt, unsigned int address, void *buf,
32 return usb4_port_retimer_nvm_read(rt->port, rt->index, address, buf, size);
35 static int nvm_read(void *priv, unsigned int offset, void *val, size_t bytes)
37 struct tb_nvm *nvm = priv;
38 struct tb_retimer *rt = tb_to_retimer(nvm->dev);
41 pm_runtime_get_sync(&rt->dev);
43 if (!mutex_trylock(&rt->tb->lock)) {
44 ret = restart_syscall();
48 ret = tb_retimer_nvm_read(rt, offset, val, bytes);
49 mutex_unlock(&rt->tb->lock);
52 pm_runtime_mark_last_busy(&rt->dev);
53 pm_runtime_put_autosuspend(&rt->dev);
58 static int nvm_write(void *priv, unsigned int offset, void *val, size_t bytes)
60 struct tb_nvm *nvm = priv;
61 struct tb_retimer *rt = tb_to_retimer(nvm->dev);
64 if (!mutex_trylock(&rt->tb->lock))
65 return restart_syscall();
67 ret = tb_nvm_write_buf(nvm, offset, val, bytes);
68 mutex_unlock(&rt->tb->lock);
73 static int tb_retimer_nvm_add(struct tb_retimer *rt)
78 nvm = tb_nvm_alloc(&rt->dev);
80 ret = PTR_ERR(nvm) == -EOPNOTSUPP ? 0 : PTR_ERR(nvm);
84 ret = tb_nvm_read_version(nvm);
88 ret = tb_nvm_add_active(nvm, nvm_read);
92 ret = tb_nvm_add_non_active(nvm, nvm_write);
100 dev_dbg(&rt->dev, "NVM upgrade disabled\n");
107 static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt)
109 unsigned int image_size;
113 ret = tb_nvm_validate(rt->nvm);
117 buf = rt->nvm->buf_data_start;
118 image_size = rt->nvm->buf_data_size;
120 ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf,
125 rt->nvm->flushed = true;
129 static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only)
135 ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0);
140 ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index);
144 usleep_range(100, 150);
147 * Check the status now if we still can access the retimer. It
148 * is expected that the below fails.
150 ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index,
153 rt->auth_status = status;
154 return status ? -EINVAL : 0;
160 static ssize_t device_show(struct device *dev, struct device_attribute *attr,
163 struct tb_retimer *rt = tb_to_retimer(dev);
165 return sysfs_emit(buf, "%#x\n", rt->device);
167 static DEVICE_ATTR_RO(device);
169 static ssize_t nvm_authenticate_show(struct device *dev,
170 struct device_attribute *attr, char *buf)
172 struct tb_retimer *rt = tb_to_retimer(dev);
175 if (!mutex_trylock(&rt->tb->lock))
176 return restart_syscall();
180 else if (rt->no_nvm_upgrade)
183 ret = sysfs_emit(buf, "%#x\n", rt->auth_status);
185 mutex_unlock(&rt->tb->lock);
190 static ssize_t nvm_authenticate_store(struct device *dev,
191 struct device_attribute *attr, const char *buf, size_t count)
193 struct tb_retimer *rt = tb_to_retimer(dev);
196 pm_runtime_get_sync(&rt->dev);
198 if (!mutex_trylock(&rt->tb->lock)) {
199 ret = restart_syscall();
208 ret = kstrtoint(buf, 10, &val);
212 /* Always clear status */
216 if (val == AUTHENTICATE_ONLY) {
217 ret = tb_retimer_nvm_authenticate(rt, true);
219 if (!rt->nvm->flushed) {
225 ret = tb_retimer_nvm_validate_and_write(rt);
226 if (ret || val == WRITE_ONLY)
229 if (val == WRITE_AND_AUTHENTICATE)
230 ret = tb_retimer_nvm_authenticate(rt, false);
235 mutex_unlock(&rt->tb->lock);
237 pm_runtime_mark_last_busy(&rt->dev);
238 pm_runtime_put_autosuspend(&rt->dev);
244 static DEVICE_ATTR_RW(nvm_authenticate);
246 static ssize_t nvm_version_show(struct device *dev,
247 struct device_attribute *attr, char *buf)
249 struct tb_retimer *rt = tb_to_retimer(dev);
252 if (!mutex_trylock(&rt->tb->lock))
253 return restart_syscall();
258 ret = sysfs_emit(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
260 mutex_unlock(&rt->tb->lock);
263 static DEVICE_ATTR_RO(nvm_version);
265 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
268 struct tb_retimer *rt = tb_to_retimer(dev);
270 return sysfs_emit(buf, "%#x\n", rt->vendor);
272 static DEVICE_ATTR_RO(vendor);
274 static struct attribute *retimer_attrs[] = {
275 &dev_attr_device.attr,
276 &dev_attr_nvm_authenticate.attr,
277 &dev_attr_nvm_version.attr,
278 &dev_attr_vendor.attr,
282 static const struct attribute_group retimer_group = {
283 .attrs = retimer_attrs,
286 static const struct attribute_group *retimer_groups[] = {
291 static void tb_retimer_release(struct device *dev)
293 struct tb_retimer *rt = tb_to_retimer(dev);
298 struct device_type tb_retimer_type = {
299 .name = "thunderbolt_retimer",
300 .groups = retimer_groups,
301 .release = tb_retimer_release,
304 static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status)
306 struct tb_retimer *rt;
310 ret = usb4_port_retimer_read(port, index, USB4_SB_VENDOR_ID, &vendor,
314 tb_port_warn(port, "failed read retimer VendorId: %d\n", ret);
318 ret = usb4_port_retimer_read(port, index, USB4_SB_PRODUCT_ID, &device,
322 tb_port_warn(port, "failed read retimer ProductId: %d\n", ret);
326 if (vendor != PCI_VENDOR_ID_INTEL && vendor != 0x8087) {
327 tb_port_info(port, "retimer NVM format of vendor %#x is not supported\n",
333 * Check that it supports NVM operations. If not then don't add
336 ret = usb4_port_retimer_nvm_sector_size(port, index);
340 rt = kzalloc(sizeof(*rt), GFP_KERNEL);
347 rt->auth_status = auth_status;
349 rt->tb = port->sw->tb;
351 rt->dev.parent = &port->usb4->dev;
352 rt->dev.bus = &tb_bus_type;
353 rt->dev.type = &tb_retimer_type;
354 dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev),
357 ret = device_register(&rt->dev);
359 dev_err(&rt->dev, "failed to register retimer: %d\n", ret);
360 put_device(&rt->dev);
364 ret = tb_retimer_nvm_add(rt);
366 dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret);
367 device_unregister(&rt->dev);
371 dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n",
372 rt->vendor, rt->device);
374 pm_runtime_no_callbacks(&rt->dev);
375 pm_runtime_set_active(&rt->dev);
376 pm_runtime_enable(&rt->dev);
377 pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY);
378 pm_runtime_mark_last_busy(&rt->dev);
379 pm_runtime_use_autosuspend(&rt->dev);
384 static void tb_retimer_remove(struct tb_retimer *rt)
386 dev_info(&rt->dev, "retimer disconnected\n");
387 tb_nvm_free(rt->nvm);
388 device_unregister(&rt->dev);
391 struct tb_retimer_lookup {
392 const struct tb_port *port;
396 static int retimer_match(struct device *dev, void *data)
398 const struct tb_retimer_lookup *lookup = data;
399 struct tb_retimer *rt = tb_to_retimer(dev);
401 return rt && rt->port == lookup->port && rt->index == lookup->index;
404 static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index)
406 struct tb_retimer_lookup lookup = { .port = port, .index = index };
409 dev = device_find_child(&port->usb4->dev, &lookup, retimer_match);
411 return tb_to_retimer(dev);
417 * tb_retimer_scan() - Scan for on-board retimers under port
418 * @port: USB4 port to scan
419 * @add: If true also registers found retimers
421 * Brings the sideband into a state where retimers can be accessed.
422 * Then Tries to enumerate on-board retimers connected to @port. Found
423 * retimers are registered as children of @port if @add is set. Does
424 * not scan for cable retimers for now.
426 int tb_retimer_scan(struct tb_port *port, bool add)
428 u32 status[TB_MAX_RETIMER_INDEX + 1] = {};
429 int ret, i, last_idx = 0;
430 struct usb4_port *usb4;
436 pm_runtime_get_sync(&usb4->dev);
439 * Send broadcast RT to make sure retimer indices facing this
442 ret = usb4_port_enumerate_retimers(port);
447 * Enable sideband channel for each retimer. We can do this
448 * regardless whether there is device connected or not.
450 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
451 usb4_port_retimer_set_inbound_sbtx(port, i);
454 * Before doing anything else, read the authentication status.
455 * If the retimer has it set, store it for the new retimer
458 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
459 usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]);
461 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
463 * Last retimer is true only for the last on-board
464 * retimer (the one connected directly to the Type-C
467 ret = usb4_port_retimer_is_last(port, i);
479 /* Add on-board retimers if they do not exist already */
480 for (i = 1; i <= last_idx; i++) {
481 struct tb_retimer *rt;
483 rt = tb_port_find_retimer(port, i);
485 put_device(&rt->dev);
487 ret = tb_retimer_add(port, i, status[i]);
488 if (ret && ret != -EOPNOTSUPP)
494 pm_runtime_mark_last_busy(&usb4->dev);
495 pm_runtime_put_autosuspend(&usb4->dev);
500 static int remove_retimer(struct device *dev, void *data)
502 struct tb_retimer *rt = tb_to_retimer(dev);
503 struct tb_port *port = data;
505 if (rt && rt->port == port)
506 tb_retimer_remove(rt);
511 * tb_retimer_remove_all() - Remove all retimers under port
512 * @port: USB4 port whose retimers to remove
514 * This removes all previously added retimers under @port.
516 void tb_retimer_remove_all(struct tb_port *port)
518 struct usb4_port *usb4;
522 device_for_each_child_reverse(&usb4->dev, port,