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
19 static int tb_retimer_nvm_read(void *priv, unsigned int offset, void *val,
22 struct tb_nvm *nvm = priv;
23 struct tb_retimer *rt = tb_to_retimer(nvm->dev);
26 pm_runtime_get_sync(&rt->dev);
28 if (!mutex_trylock(&rt->tb->lock)) {
29 ret = restart_syscall();
33 ret = usb4_port_retimer_nvm_read(rt->port, rt->index, offset, val, bytes);
34 mutex_unlock(&rt->tb->lock);
37 pm_runtime_mark_last_busy(&rt->dev);
38 pm_runtime_put_autosuspend(&rt->dev);
43 static int tb_retimer_nvm_write(void *priv, unsigned int offset, void *val,
46 struct tb_nvm *nvm = priv;
47 struct tb_retimer *rt = tb_to_retimer(nvm->dev);
50 if (!mutex_trylock(&rt->tb->lock))
51 return restart_syscall();
53 ret = tb_nvm_write_buf(nvm, offset, val, bytes);
54 mutex_unlock(&rt->tb->lock);
59 static int tb_retimer_nvm_add(struct tb_retimer *rt)
65 nvm = tb_nvm_alloc(&rt->dev);
69 ret = usb4_port_retimer_nvm_read(rt->port, rt->index, NVM_VERSION, &val,
74 nvm->major = val >> 16;
75 nvm->minor = val >> 8;
77 ret = usb4_port_retimer_nvm_read(rt->port, rt->index, NVM_FLASH_SIZE,
82 nvm_size = (SZ_1M << (val & 7)) / 8;
83 nvm_size = (nvm_size - SZ_16K) / 2;
85 ret = tb_nvm_add_active(nvm, nvm_size, tb_retimer_nvm_read);
89 ret = tb_nvm_add_non_active(nvm, NVM_MAX_SIZE, tb_retimer_nvm_write);
101 static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt)
103 unsigned int image_size, hdr_size;
104 const u8 *buf = rt->nvm->buf;
108 image_size = rt->nvm->buf_data_size;
109 if (image_size < NVM_MIN_SIZE || image_size > NVM_MAX_SIZE)
113 * FARB pointer must point inside the image and must at least
114 * contain parts of the digital section we will be reading here.
116 hdr_size = (*(u32 *)buf) & 0xffffff;
117 if (hdr_size + NVM_DEVID + 2 >= image_size)
120 /* Digital section start should be aligned to 4k page */
121 if (!IS_ALIGNED(hdr_size, SZ_4K))
125 * Read digital section size and check that it also fits inside
128 ds_size = *(u16 *)(buf + hdr_size);
129 if (ds_size >= image_size)
133 * Make sure the device ID in the image matches the retimer
136 device = *(u16 *)(buf + hdr_size + NVM_DEVID);
137 if (device != rt->device)
140 /* Skip headers in the image */
142 image_size -= hdr_size;
144 ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf,
147 rt->nvm->flushed = true;
152 static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only)
158 ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0);
163 ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index);
167 usleep_range(100, 150);
170 * Check the status now if we still can access the retimer. It
171 * is expected that the below fails.
173 ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index,
176 rt->auth_status = status;
177 return status ? -EINVAL : 0;
183 static ssize_t device_show(struct device *dev, struct device_attribute *attr,
186 struct tb_retimer *rt = tb_to_retimer(dev);
188 return sprintf(buf, "%#x\n", rt->device);
190 static DEVICE_ATTR_RO(device);
192 static ssize_t nvm_authenticate_show(struct device *dev,
193 struct device_attribute *attr, char *buf)
195 struct tb_retimer *rt = tb_to_retimer(dev);
198 if (!mutex_trylock(&rt->tb->lock))
199 return restart_syscall();
204 ret = sprintf(buf, "%#x\n", rt->auth_status);
206 mutex_unlock(&rt->tb->lock);
211 static ssize_t nvm_authenticate_store(struct device *dev,
212 struct device_attribute *attr, const char *buf, size_t count)
214 struct tb_retimer *rt = tb_to_retimer(dev);
217 pm_runtime_get_sync(&rt->dev);
219 if (!mutex_trylock(&rt->tb->lock)) {
220 ret = restart_syscall();
229 ret = kstrtoint(buf, 10, &val);
233 /* Always clear status */
237 if (val == AUTHENTICATE_ONLY) {
238 ret = tb_retimer_nvm_authenticate(rt, true);
240 if (!rt->nvm->flushed) {
246 ret = tb_retimer_nvm_validate_and_write(rt);
247 if (ret || val == WRITE_ONLY)
250 if (val == WRITE_AND_AUTHENTICATE)
251 ret = tb_retimer_nvm_authenticate(rt, false);
256 mutex_unlock(&rt->tb->lock);
258 pm_runtime_mark_last_busy(&rt->dev);
259 pm_runtime_put_autosuspend(&rt->dev);
265 static DEVICE_ATTR_RW(nvm_authenticate);
267 static ssize_t nvm_version_show(struct device *dev,
268 struct device_attribute *attr, char *buf)
270 struct tb_retimer *rt = tb_to_retimer(dev);
273 if (!mutex_trylock(&rt->tb->lock))
274 return restart_syscall();
279 ret = sprintf(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
281 mutex_unlock(&rt->tb->lock);
284 static DEVICE_ATTR_RO(nvm_version);
286 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
289 struct tb_retimer *rt = tb_to_retimer(dev);
291 return sprintf(buf, "%#x\n", rt->vendor);
293 static DEVICE_ATTR_RO(vendor);
295 static struct attribute *retimer_attrs[] = {
296 &dev_attr_device.attr,
297 &dev_attr_nvm_authenticate.attr,
298 &dev_attr_nvm_version.attr,
299 &dev_attr_vendor.attr,
303 static const struct attribute_group retimer_group = {
304 .attrs = retimer_attrs,
307 static const struct attribute_group *retimer_groups[] = {
312 static void tb_retimer_release(struct device *dev)
314 struct tb_retimer *rt = tb_to_retimer(dev);
319 struct device_type tb_retimer_type = {
320 .name = "thunderbolt_retimer",
321 .groups = retimer_groups,
322 .release = tb_retimer_release,
325 static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status)
327 struct tb_retimer *rt;
331 ret = usb4_port_retimer_read(port, index, USB4_SB_VENDOR_ID, &vendor,
335 tb_port_warn(port, "failed read retimer VendorId: %d\n", ret);
339 ret = usb4_port_retimer_read(port, index, USB4_SB_PRODUCT_ID, &device,
343 tb_port_warn(port, "failed read retimer ProductId: %d\n", ret);
347 if (vendor != PCI_VENDOR_ID_INTEL && vendor != 0x8087) {
348 tb_port_info(port, "retimer NVM format of vendor %#x is not supported\n",
354 * Check that it supports NVM operations. If not then don't add
357 ret = usb4_port_retimer_nvm_sector_size(port, index);
361 rt = kzalloc(sizeof(*rt), GFP_KERNEL);
368 rt->auth_status = auth_status;
370 rt->tb = port->sw->tb;
372 rt->dev.parent = &port->usb4->dev;
373 rt->dev.bus = &tb_bus_type;
374 rt->dev.type = &tb_retimer_type;
375 dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev),
378 ret = device_register(&rt->dev);
380 dev_err(&rt->dev, "failed to register retimer: %d\n", ret);
381 put_device(&rt->dev);
385 ret = tb_retimer_nvm_add(rt);
387 dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret);
388 device_unregister(&rt->dev);
392 dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n",
393 rt->vendor, rt->device);
395 pm_runtime_no_callbacks(&rt->dev);
396 pm_runtime_set_active(&rt->dev);
397 pm_runtime_enable(&rt->dev);
398 pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY);
399 pm_runtime_mark_last_busy(&rt->dev);
400 pm_runtime_use_autosuspend(&rt->dev);
405 static void tb_retimer_remove(struct tb_retimer *rt)
407 dev_info(&rt->dev, "retimer disconnected\n");
408 tb_nvm_free(rt->nvm);
409 device_unregister(&rt->dev);
412 struct tb_retimer_lookup {
413 const struct tb_port *port;
417 static int retimer_match(struct device *dev, void *data)
419 const struct tb_retimer_lookup *lookup = data;
420 struct tb_retimer *rt = tb_to_retimer(dev);
422 return rt && rt->port == lookup->port && rt->index == lookup->index;
425 static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index)
427 struct tb_retimer_lookup lookup = { .port = port, .index = index };
430 dev = device_find_child(&port->usb4->dev, &lookup, retimer_match);
432 return tb_to_retimer(dev);
438 * tb_retimer_scan() - Scan for on-board retimers under port
439 * @port: USB4 port to scan
440 * @add: If true also registers found retimers
442 * Brings the sideband into a state where retimers can be accessed.
443 * Then Tries to enumerate on-board retimers connected to @port. Found
444 * retimers are registered as children of @port if @add is set. Does
445 * not scan for cable retimers for now.
447 int tb_retimer_scan(struct tb_port *port, bool add)
449 u32 status[TB_MAX_RETIMER_INDEX + 1] = {};
450 int ret, i, last_idx = 0;
451 struct usb4_port *usb4;
457 pm_runtime_get_sync(&usb4->dev);
460 * Send broadcast RT to make sure retimer indices facing this
463 ret = usb4_port_enumerate_retimers(port);
468 * Enable sideband channel for each retimer. We can do this
469 * regardless whether there is device connected or not.
471 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
472 usb4_port_retimer_set_inbound_sbtx(port, i);
475 * Before doing anything else, read the authentication status.
476 * If the retimer has it set, store it for the new retimer
479 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
480 usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]);
482 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
484 * Last retimer is true only for the last on-board
485 * retimer (the one connected directly to the Type-C
488 ret = usb4_port_retimer_is_last(port, i);
500 /* Add on-board retimers if they do not exist already */
501 for (i = 1; i <= last_idx; i++) {
502 struct tb_retimer *rt;
504 rt = tb_port_find_retimer(port, i);
506 put_device(&rt->dev);
508 ret = tb_retimer_add(port, i, status[i]);
509 if (ret && ret != -EOPNOTSUPP)
515 pm_runtime_mark_last_busy(&usb4->dev);
516 pm_runtime_put_autosuspend(&usb4->dev);
521 static int remove_retimer(struct device *dev, void *data)
523 struct tb_retimer *rt = tb_to_retimer(dev);
524 struct tb_port *port = data;
526 if (rt && rt->port == port)
527 tb_retimer_remove(rt);
532 * tb_retimer_remove_all() - Remove all retimers under port
533 * @port: USB4 port whose retimers to remove
535 * This removes all previously added retimers under @port.
537 void tb_retimer_remove_all(struct tb_port *port)
539 struct usb4_port *usb4;
543 device_for_each_child_reverse(&usb4->dev, port,