xref: /linux/drivers/thunderbolt/retimer.c (revision 3df692169e8486fc3dd91fcd5ea81c27a0bac033)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Thunderbolt/USB4 retimer support.
4  *
5  * Copyright (C) 2020, Intel Corporation
6  * Authors: Kranthi Kuntala <kranthi.kuntala@intel.com>
7  *	    Mika Westerberg <mika.westerberg@linux.intel.com>
8  */
9 
10 #include <linux/delay.h>
11 #include <linux/pm_runtime.h>
12 #include <linux/sched/signal.h>
13 
14 #include "sb_regs.h"
15 #include "tb.h"
16 
17 #define TB_MAX_RETIMER_INDEX	6
18 
19 /**
20  * tb_retimer_nvm_read() - Read contents of retimer NVM
21  * @rt: Retimer device
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
25  *
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.
28  */
29 int tb_retimer_nvm_read(struct tb_retimer *rt, unsigned int address, void *buf,
30 			size_t size)
31 {
32 	return usb4_port_retimer_nvm_read(rt->port, rt->index, address, buf, size);
33 }
34 
35 static int nvm_read(void *priv, unsigned int offset, void *val, size_t bytes)
36 {
37 	struct tb_nvm *nvm = priv;
38 	struct tb_retimer *rt = tb_to_retimer(nvm->dev);
39 	int ret;
40 
41 	pm_runtime_get_sync(&rt->dev);
42 
43 	if (!mutex_trylock(&rt->tb->lock)) {
44 		ret = restart_syscall();
45 		goto out;
46 	}
47 
48 	ret = tb_retimer_nvm_read(rt, offset, val, bytes);
49 	mutex_unlock(&rt->tb->lock);
50 
51 out:
52 	pm_runtime_mark_last_busy(&rt->dev);
53 	pm_runtime_put_autosuspend(&rt->dev);
54 
55 	return ret;
56 }
57 
58 static int nvm_write(void *priv, unsigned int offset, void *val, size_t bytes)
59 {
60 	struct tb_nvm *nvm = priv;
61 	struct tb_retimer *rt = tb_to_retimer(nvm->dev);
62 	int ret = 0;
63 
64 	if (!mutex_trylock(&rt->tb->lock))
65 		return restart_syscall();
66 
67 	ret = tb_nvm_write_buf(nvm, offset, val, bytes);
68 	mutex_unlock(&rt->tb->lock);
69 
70 	return ret;
71 }
72 
73 static int tb_retimer_nvm_add(struct tb_retimer *rt)
74 {
75 	struct tb_nvm *nvm;
76 	int ret;
77 
78 	nvm = tb_nvm_alloc(&rt->dev);
79 	if (IS_ERR(nvm)) {
80 		ret = PTR_ERR(nvm) == -EOPNOTSUPP ? 0 : PTR_ERR(nvm);
81 		goto err_nvm;
82 	}
83 
84 	ret = tb_nvm_read_version(nvm);
85 	if (ret)
86 		goto err_nvm;
87 
88 	ret = tb_nvm_add_active(nvm, nvm_read);
89 	if (ret)
90 		goto err_nvm;
91 
92 	ret = tb_nvm_add_non_active(nvm, nvm_write);
93 	if (ret)
94 		goto err_nvm;
95 
96 	rt->nvm = nvm;
97 	dev_dbg(&rt->dev, "NVM version %x.%x\n", nvm->major, nvm->minor);
98 	return 0;
99 
100 err_nvm:
101 	dev_dbg(&rt->dev, "NVM upgrade disabled\n");
102 	if (!IS_ERR(nvm))
103 		tb_nvm_free(nvm);
104 
105 	return ret;
106 }
107 
108 static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt)
109 {
110 	unsigned int image_size;
111 	const u8 *buf;
112 	int ret;
113 
114 	ret = tb_nvm_validate(rt->nvm);
115 	if (ret)
116 		return ret;
117 
118 	buf = rt->nvm->buf_data_start;
119 	image_size = rt->nvm->buf_data_size;
120 
121 	ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf,
122 					 image_size);
123 	if (ret)
124 		return ret;
125 
126 	rt->nvm->flushed = true;
127 	return 0;
128 }
129 
130 static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only)
131 {
132 	u32 status;
133 	int ret;
134 
135 	if (auth_only) {
136 		ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0);
137 		if (ret)
138 			return ret;
139 	}
140 
141 	ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index);
142 	if (ret)
143 		return ret;
144 
145 	usleep_range(100, 150);
146 
147 	/*
148 	 * Check the status now if we still can access the retimer. It
149 	 * is expected that the below fails.
150 	 */
151 	ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index,
152 							&status);
153 	if (!ret) {
154 		rt->auth_status = status;
155 		return status ? -EINVAL : 0;
156 	}
157 
158 	return 0;
159 }
160 
161 static ssize_t device_show(struct device *dev, struct device_attribute *attr,
162 			   char *buf)
163 {
164 	struct tb_retimer *rt = tb_to_retimer(dev);
165 
166 	return sysfs_emit(buf, "%#x\n", rt->device);
167 }
168 static DEVICE_ATTR_RO(device);
169 
170 static ssize_t nvm_authenticate_show(struct device *dev,
171 	struct device_attribute *attr, char *buf)
172 {
173 	struct tb_retimer *rt = tb_to_retimer(dev);
174 	int ret;
175 
176 	if (!mutex_trylock(&rt->tb->lock))
177 		return restart_syscall();
178 
179 	if (!rt->nvm)
180 		ret = -EAGAIN;
181 	else if (rt->no_nvm_upgrade)
182 		ret = -EOPNOTSUPP;
183 	else
184 		ret = sysfs_emit(buf, "%#x\n", rt->auth_status);
185 
186 	mutex_unlock(&rt->tb->lock);
187 
188 	return ret;
189 }
190 
191 static void tb_retimer_nvm_authenticate_status(struct tb_port *port, u32 *status)
192 {
193 	int i;
194 
195 	tb_port_dbg(port, "reading NVM authentication status of retimers\n");
196 
197 	/*
198 	 * Before doing anything else, read the authentication status.
199 	 * If the retimer has it set, store it for the new retimer
200 	 * device instance.
201 	 */
202 	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
203 		usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]);
204 }
205 
206 static void tb_retimer_set_inbound_sbtx(struct tb_port *port)
207 {
208 	int i;
209 
210 	/*
211 	 * When USB4 port is online sideband communications are
212 	 * already up.
213 	 */
214 	if (!usb4_port_device_is_offline(port->usb4))
215 		return;
216 
217 	tb_port_dbg(port, "enabling sideband transactions\n");
218 
219 	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
220 		usb4_port_retimer_set_inbound_sbtx(port, i);
221 }
222 
223 static void tb_retimer_unset_inbound_sbtx(struct tb_port *port)
224 {
225 	int i;
226 
227 	/*
228 	 * When USB4 port is offline we need to keep the sideband
229 	 * communications up to make it possible to communicate with
230 	 * the connected retimers.
231 	 */
232 	if (usb4_port_device_is_offline(port->usb4))
233 		return;
234 
235 	tb_port_dbg(port, "disabling sideband transactions\n");
236 
237 	for (i = TB_MAX_RETIMER_INDEX; i >= 1; i--)
238 		usb4_port_retimer_unset_inbound_sbtx(port, i);
239 }
240 
241 static ssize_t nvm_authenticate_store(struct device *dev,
242 	struct device_attribute *attr, const char *buf, size_t count)
243 {
244 	struct tb_retimer *rt = tb_to_retimer(dev);
245 	int val, ret;
246 
247 	pm_runtime_get_sync(&rt->dev);
248 
249 	if (!mutex_trylock(&rt->tb->lock)) {
250 		ret = restart_syscall();
251 		goto exit_rpm;
252 	}
253 
254 	if (!rt->nvm) {
255 		ret = -EAGAIN;
256 		goto exit_unlock;
257 	}
258 
259 	ret = kstrtoint(buf, 10, &val);
260 	if (ret)
261 		goto exit_unlock;
262 
263 	/* Always clear status */
264 	rt->auth_status = 0;
265 
266 	if (val) {
267 		/*
268 		 * When NVM authentication starts the retimer is not
269 		 * accessible so calling tb_retimer_unset_inbound_sbtx()
270 		 * will fail and therefore we do not call it. Exception
271 		 * is when the validation fails or we only write the new
272 		 * NVM image without authentication.
273 		 */
274 		tb_retimer_set_inbound_sbtx(rt->port);
275 		if (val == AUTHENTICATE_ONLY) {
276 			ret = tb_retimer_nvm_authenticate(rt, true);
277 		} else {
278 			if (!rt->nvm->flushed) {
279 				if (!rt->nvm->buf) {
280 					ret = -EINVAL;
281 					goto exit_unlock;
282 				}
283 
284 				ret = tb_retimer_nvm_validate_and_write(rt);
285 				if (ret || val == WRITE_ONLY)
286 					goto exit_unlock;
287 			}
288 			if (val == WRITE_AND_AUTHENTICATE)
289 				ret = tb_retimer_nvm_authenticate(rt, false);
290 		}
291 	}
292 
293 exit_unlock:
294 	if (ret || val == WRITE_ONLY)
295 		tb_retimer_unset_inbound_sbtx(rt->port);
296 	mutex_unlock(&rt->tb->lock);
297 exit_rpm:
298 	pm_runtime_mark_last_busy(&rt->dev);
299 	pm_runtime_put_autosuspend(&rt->dev);
300 
301 	if (ret)
302 		return ret;
303 	return count;
304 }
305 static DEVICE_ATTR_RW(nvm_authenticate);
306 
307 static ssize_t nvm_version_show(struct device *dev,
308 				struct device_attribute *attr, char *buf)
309 {
310 	struct tb_retimer *rt = tb_to_retimer(dev);
311 	int ret;
312 
313 	if (!mutex_trylock(&rt->tb->lock))
314 		return restart_syscall();
315 
316 	if (!rt->nvm)
317 		ret = -EAGAIN;
318 	else
319 		ret = sysfs_emit(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
320 
321 	mutex_unlock(&rt->tb->lock);
322 	return ret;
323 }
324 static DEVICE_ATTR_RO(nvm_version);
325 
326 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
327 			   char *buf)
328 {
329 	struct tb_retimer *rt = tb_to_retimer(dev);
330 
331 	return sysfs_emit(buf, "%#x\n", rt->vendor);
332 }
333 static DEVICE_ATTR_RO(vendor);
334 
335 static struct attribute *retimer_attrs[] = {
336 	&dev_attr_device.attr,
337 	&dev_attr_nvm_authenticate.attr,
338 	&dev_attr_nvm_version.attr,
339 	&dev_attr_vendor.attr,
340 	NULL
341 };
342 
343 static const struct attribute_group retimer_group = {
344 	.attrs = retimer_attrs,
345 };
346 
347 static const struct attribute_group *retimer_groups[] = {
348 	&retimer_group,
349 	NULL
350 };
351 
352 static void tb_retimer_release(struct device *dev)
353 {
354 	struct tb_retimer *rt = tb_to_retimer(dev);
355 
356 	kfree(rt);
357 }
358 
359 struct device_type tb_retimer_type = {
360 	.name = "thunderbolt_retimer",
361 	.groups = retimer_groups,
362 	.release = tb_retimer_release,
363 };
364 
365 static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status)
366 {
367 	struct tb_retimer *rt;
368 	u32 vendor, device;
369 	int ret;
370 
371 	ret = usb4_port_retimer_read(port, index, USB4_SB_VENDOR_ID, &vendor,
372 				     sizeof(vendor));
373 	if (ret) {
374 		if (ret != -ENODEV)
375 			tb_port_warn(port, "failed read retimer VendorId: %d\n", ret);
376 		return ret;
377 	}
378 
379 	ret = usb4_port_retimer_read(port, index, USB4_SB_PRODUCT_ID, &device,
380 				     sizeof(device));
381 	if (ret) {
382 		if (ret != -ENODEV)
383 			tb_port_warn(port, "failed read retimer ProductId: %d\n", ret);
384 		return ret;
385 	}
386 
387 	/*
388 	 * Check that it supports NVM operations. If not then don't add
389 	 * the device at all.
390 	 */
391 	ret = usb4_port_retimer_nvm_sector_size(port, index);
392 	if (ret < 0)
393 		return ret;
394 
395 	rt = kzalloc(sizeof(*rt), GFP_KERNEL);
396 	if (!rt)
397 		return -ENOMEM;
398 
399 	rt->index = index;
400 	rt->vendor = vendor;
401 	rt->device = device;
402 	rt->auth_status = auth_status;
403 	rt->port = port;
404 	rt->tb = port->sw->tb;
405 
406 	rt->dev.parent = &port->usb4->dev;
407 	rt->dev.bus = &tb_bus_type;
408 	rt->dev.type = &tb_retimer_type;
409 	dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev),
410 		     port->port, index);
411 
412 	ret = device_register(&rt->dev);
413 	if (ret) {
414 		dev_err(&rt->dev, "failed to register retimer: %d\n", ret);
415 		put_device(&rt->dev);
416 		return ret;
417 	}
418 
419 	ret = tb_retimer_nvm_add(rt);
420 	if (ret) {
421 		dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret);
422 		device_unregister(&rt->dev);
423 		return ret;
424 	}
425 
426 	dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n",
427 		 rt->vendor, rt->device);
428 
429 	pm_runtime_no_callbacks(&rt->dev);
430 	pm_runtime_set_active(&rt->dev);
431 	pm_runtime_enable(&rt->dev);
432 	pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY);
433 	pm_runtime_mark_last_busy(&rt->dev);
434 	pm_runtime_use_autosuspend(&rt->dev);
435 
436 	return 0;
437 }
438 
439 static void tb_retimer_remove(struct tb_retimer *rt)
440 {
441 	dev_info(&rt->dev, "retimer disconnected\n");
442 	tb_nvm_free(rt->nvm);
443 	device_unregister(&rt->dev);
444 }
445 
446 struct tb_retimer_lookup {
447 	const struct tb_port *port;
448 	u8 index;
449 };
450 
451 static int retimer_match(struct device *dev, void *data)
452 {
453 	const struct tb_retimer_lookup *lookup = data;
454 	struct tb_retimer *rt = tb_to_retimer(dev);
455 
456 	return rt && rt->port == lookup->port && rt->index == lookup->index;
457 }
458 
459 static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index)
460 {
461 	struct tb_retimer_lookup lookup = { .port = port, .index = index };
462 	struct device *dev;
463 
464 	dev = device_find_child(&port->usb4->dev, &lookup, retimer_match);
465 	if (dev)
466 		return tb_to_retimer(dev);
467 
468 	return NULL;
469 }
470 
471 /**
472  * tb_retimer_scan() - Scan for on-board retimers under port
473  * @port: USB4 port to scan
474  * @add: If true also registers found retimers
475  *
476  * Brings the sideband into a state where retimers can be accessed.
477  * Then Tries to enumerate on-board retimers connected to @port. Found
478  * retimers are registered as children of @port if @add is set.  Does
479  * not scan for cable retimers for now.
480  */
481 int tb_retimer_scan(struct tb_port *port, bool add)
482 {
483 	u32 status[TB_MAX_RETIMER_INDEX + 1] = {};
484 	int ret, i, last_idx = 0;
485 
486 	/*
487 	 * Send broadcast RT to make sure retimer indices facing this
488 	 * port are set.
489 	 */
490 	ret = usb4_port_enumerate_retimers(port);
491 	if (ret)
492 		return ret;
493 
494 	/*
495 	 * Immediately after sending enumerate retimers read the
496 	 * authentication status of each retimer.
497 	 */
498 	tb_retimer_nvm_authenticate_status(port, status);
499 
500 	/*
501 	 * Enable sideband channel for each retimer. We can do this
502 	 * regardless whether there is device connected or not.
503 	 */
504 	tb_retimer_set_inbound_sbtx(port);
505 
506 	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
507 		/*
508 		 * Last retimer is true only for the last on-board
509 		 * retimer (the one connected directly to the Type-C
510 		 * port).
511 		 */
512 		ret = usb4_port_retimer_is_last(port, i);
513 		if (ret > 0)
514 			last_idx = i;
515 		else if (ret < 0)
516 			break;
517 	}
518 
519 	tb_retimer_unset_inbound_sbtx(port);
520 
521 	if (!last_idx)
522 		return 0;
523 
524 	/* Add on-board retimers if they do not exist already */
525 	ret = 0;
526 	for (i = 1; i <= last_idx; i++) {
527 		struct tb_retimer *rt;
528 
529 		rt = tb_port_find_retimer(port, i);
530 		if (rt) {
531 			put_device(&rt->dev);
532 		} else if (add) {
533 			ret = tb_retimer_add(port, i, status[i]);
534 			if (ret && ret != -EOPNOTSUPP)
535 				break;
536 		}
537 	}
538 
539 	return ret;
540 }
541 
542 static int remove_retimer(struct device *dev, void *data)
543 {
544 	struct tb_retimer *rt = tb_to_retimer(dev);
545 	struct tb_port *port = data;
546 
547 	if (rt && rt->port == port)
548 		tb_retimer_remove(rt);
549 	return 0;
550 }
551 
552 /**
553  * tb_retimer_remove_all() - Remove all retimers under port
554  * @port: USB4 port whose retimers to remove
555  *
556  * This removes all previously added retimers under @port.
557  */
558 void tb_retimer_remove_all(struct tb_port *port)
559 {
560 	struct usb4_port *usb4;
561 
562 	usb4 = port->usb4;
563 	if (usb4)
564 		device_for_each_child_reverse(&usb4->dev, port,
565 					      remove_retimer);
566 }
567